Acceptance contract first
The runtime records what success means, what evidence is required, and what actions are allowed before the agent starts changing things.
OPEN-SOURCE · AUTONOMOUS DELIVERY · VERIFIED RECEIPTS
Loop.
One instruction in. Verified delivery—or an explicit failure—out.
Loop turns a goal into an acceptance contract, executes and repairs the work, independently reruns checks on fresh snapshots, and returns reviewable changes with a replayable Receipt.
HOW IT WORKS
A bounded path from request to evidence.
- 01
Contract
Translate the request into explicit acceptance criteria, required artifacts, authority limits, and checks before execution begins.
- 02
Execute
Plan, use tools, inspect failures, and repair the implementation inside a bounded runtime rather than stopping at generated code.
- 03
Verify
Run declared checks independently against fresh snapshots so completion cannot be self-certified by the same working context.
- 04
Deliver
Return reviewable artifacts or a Git change set with hashes, events, check results, and enough evidence to replay the decision.
DESIGN
The product is the contract.
The interface is useful because it exposes what happened, where confidence comes from, and where the system stops—not because an agent produced a confident paragraph.
Failure becomes evidence
Tool errors and failed checks feed the next repair step instead of disappearing behind a generic completion message.
Independent verification
Checks rerun outside the implementation context against fresh snapshots, reducing the chance that contaminated state produces a false pass.
Replayable Receipts
A hash-linked event ledger preserves inputs, outputs, check results, and delivery state for later inspection and replay.
Guarded delivery
Apply, Discard, and Undo make the handoff an explicit, reversible operation rather than an invisible mutation of the user's workspace.
Local to orchestrated
Run the deterministic demo locally, use containerized execution, or deploy the runtime with Kubernetes profiles for stronger isolation.
QUICK START
Inspect the real thing.
The keyless deterministic demo exercises the contract, execution, verification, delivery, and Receipt path without requiring a model-provider account.
TERMINALRESEARCH RELEASE · v0.1.0
$ git clone https://github.com/chriswu727/loop-agent.git
$ cd loop-agent
$ make demoVERIFIABLE SCOPE
- 458
- tests in the full local check
- 72%
- reported backend coverage
- 1
- acceptance contract per run
- REPLAY
- hash-linked receipts
These figures describe the v0.1.0 repository and its deterministic checks. They demonstrate the runtime contract and implementation quality, not autonomous success across arbitrary real-world projects.
HONEST BOUNDARIES
What this does not prove.
- 01Loop v0.1.0 is a research release, not a claim of production mileage across arbitrary repositories or organizations.
- 02The deterministic demo proves the delivery protocol; it does not measure the quality of every model, prompt, or provider-backed workload.
- 03The inline demo profile intentionally trades isolation for approachability and is not the right boundary for untrusted commands.
- 04Provider-backed tasks need workload-specific evaluation, cost limits, and human review before they are trusted with consequential delivery.
- 05Use the container or Kubernetes execution profiles when the command surface or artifact boundary requires stronger isolation.
FAQ
Before you try it.
Is Loop another coding chat interface?
No. It is a bounded delivery runtime: it formalizes acceptance, executes work, independently verifies the result, and returns evidence alongside the implementation.
Can Loop demonstrate its workflow without an API key?
Yes. The deterministic make demo path exercises the full contract-to-Receipt lifecycle without a model provider. Real provider-backed workloads are a separate evaluation surface.
Does a Receipt prove the software is correct?
No. It proves what contract and checks ran, against which artifacts, and what they returned. The strength of the conclusion still depends on the quality of the acceptance criteria and checks.
Is Loop ready for unattended production changes?
Not as a blanket claim. v0.1.0 is a research release. Consequential use should add workload-specific evaluation, strong isolation, bounded authority, and human review.
OPEN SOURCE