AI Engineer World's Fair 2026
What Does Done Even Mean? Agents and Paperclip's Liveness Model - Dotta, Paperclip
Loading slides…
Read the talk
What Does Done Even Mean? Agents and Paperclip's Liveness Model
A passing pull request is only one kind of completion. Paperclip’s liveness model separates evidence, approval and ownership so agent work can keep moving without losing accountability.
From a talk by Dotta
Before you start: Familiarity with pull requests, automated tests and coding agents is helpful; no prior Paperclip experience is required.
A green check mark hides different claims
An agent opens a pull request, passes the tests, updates the documentation, closes the issue and comments, “Looks done to me.” Is it ready to merge? Ready to deploy? Ready to announce to customers? Those are different operational claims, even if the task manager represents all of them with one green check mark.
Dotta, creator of Paperclip, introduces the problem with the provocative premise that “programming is solved.” His practical concern is the verification bottleneck: agents can produce code and documentation faster than people can check them. Generating another completed task can therefore create more work for the human responsible for deciding whether to trust it. A checkbox does not resolve that imbalance.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Completion has contents and levels
Done is a bundle of claims. An artifact exists; evidence supports its completion; a rubric defines what completion means. The bundle also includes the owner of the next step and the action that owner should take. Without those last two pieces, finishing one agent’s work can leave the overall task stranded.
The strength of the claim also matters. Dotta moves through progressively stronger forms of assurance:
| Level | What it establishes |
|---|---|
| Producer claim | The author says the work is complete. |
| Independent review | Another party finds no obvious issues. |
| Verification | Evidence meets a specified standard. |
| Approval | An authorized person signs off. |
| Accountability | Someone stands behind the decision. |
| Real-world outcome | The result survives actual conditions. |
These levels answer different questions. Finding no obvious issues does not itself establish that a standard was met, and meeting a standard does not identify who has authority to approve the result. Ideally, the outcome eventually earns confidence through real-world use—but exhaustive human verification cannot support arbitrarily large volumes of agent work.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Keep work moving without abandoning verification
Requiring a human signature on every task does not make the verification bottleneck disappear. As volume grows, sign-off can become a ritual rather than a meaningful check. The alternative needs a task-progression protocol: rules that move work forward while preventing invalid states. A control plane connects execution to those contracts and constraints, including which agent receives the next handoff.
Human review supplies assurance, but waiting for it pauses progress. Dotta describes liveness informally as work continuing without blockers. The orchestration problem is to balance that forward movement with verification:
- Unrestricted execution: Agents keep producing, but without approvals or quality control the output can accumulate into work that is worse than having produced nothing.
- Pure review: Everything waits for inspection, creating a queue that people cannot realistically clear.
Separating the claims inside completion makes it possible to reason about what must be checked before the next step, instead of routing every result through the same undifferentiated approval gate.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
A task loop needs enforced rules
A loop that reads tasks and asks agents to work on them looks sufficient until tasks depend on other tasks. Dependency trees introduce blockers; multiple agents introduce coordination; idempotent checkouts and checkout locks introduce ownership constraints. These details make continued execution and meaningful verification a control-plane problem.
Dotta identifies three invariants for that control plane:
- Productive work continues. The system keeps useful execution moving.
- Only real blockers stop work. A halt must correspond to an actual impediment.
- Infinite loops are bounded. Attempts to make progress cannot repeat without limits.
Together, these requirements rule out both an orchestration system that silently stalls and one that keeps agents busy indefinitely without achieving anything.
Paperclip’s mechanisms give those requirements concrete places to act. Tasks have explicit allowed transitions. Dependencies are first-class blockers enforced by the control plane. Interactive human approvals leave an audit trail, while reviewers and approvers can be assigned explicitly so that finishing the producer’s step can hand work to another agent for review. The handoff becomes part of the task’s structure rather than something the producer must improvise.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Watchdogs supervise a goal across harnesses
A watchdog adds goal-directed supervision. Dotta describes another agent receiving a goal and pushing the working agents to continue until that goal is achieved, calling this “maximizer mode.” The useful distinction is between an agent finishing its local assignment and a supervisor checking whether the larger goal still needs work. This is a supervision objective, not a guarantee that every goal can be achieved.
The watchdog is intended to be harness agnostic. Dotta names Pi, OpenClaw, Hermes, Claude Code and Codex as possible agent environments beneath the same supervisory interface. The control plane can express a consistent goal-completion contract without requiring every worker to use the same harness.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Represent done as an object
Replace the completion Boolean with a completion object. This recommendation applies beyond Paperclip. Humans often fill in missing context implicitly; agents need to distinguish the artifact, the scope of the claim, the standard, the evidence, the verifier, the sign-off authority, the remaining risk and the next action.
For the opening pull request, a completion record could look like this. The assigned roles and rubric make the example concrete: the producer has reported tests and documentation complete, while independent verification and merge approval remain pending.
json
{
"artifact": "pull request",
"scope": "ready for merge review",
"rubric": [
"tests pass",
"documentation is updated",
"independent review finds no obvious issues"
],
"evidence": [
{ "claim": "tests pass", "reportedBy": "author" },
{ "claim": "documentation updated", "reportedBy": "author" }
],
"verifier": {
"owner": "review agent",
"status": "pending"
},
"signOff": {
"authority": "maintainer",
"status": "pending"
},
"remainingRisk": [
"independent verification is incomplete",
"deployment readiness is not established"
],
"nextAction": {
"owner": "review agent",
"action": "inspect the changes and supporting evidence"
}
}
The record preserves the producer’s work without upgrading it into approval. It also gives the next agent a specific assignment. A single done: true cannot express those distinctions.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Give independent verifiers the tools to check
Dotta introduces his practical checklist with an aspiration to get a hundred times more work done, rather than a measured productivity result. The procedure starts by defining completion for the particular task:
- Specify the completion standard. Decide exactly what the task must establish.
- Separate the verifier from the author. Dotta suggests using a different model or agent system—for example, Claude writes the code and Codex verifies it.
- Require evidence. Ask the agent to supply support for its claim, rather than simply asking whether it is done.
Evidence requires tools. Build the custom browser harness, provide screenshot capture and give the verifier browser access. Add agent hooks or tooling that let it click buttons and exercise the result itself. A verifier that can inspect actual behavior has something more substantial to evaluate than the author’s description of what should work.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Make the next owner explicit
The final requirement is chain of custody: every agent should know who receives the work immediately after its own step finishes. In the pull-request example, producing the change leads to review; the pending review and approval remain visible rather than disappearing when the author closes the issue.
A single-line instruction followed by acceptance of whatever comes back leaves too much implicit for work someone must answer for. Define completion in enough detail that the agents can check each claim, and give them a structure that carries evidence and responsibility through the handoff. The task is ready to advance when the claims required for its next step have been met.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Resources
From the talk
Open-source agent orchestration platform with task ownership, execution locks, approvals, budgets and setup instructions.
Updates since the talk
- Paperclip execution semanticsDocumentation
Current contracts for blockers, waiting paths, task watchdogs and recovery when assigned work stops progressing.
- Paperclip implementation specificationDocumentation
State machines and authority rules connecting task execution, review, approval and recovery.
Guide to connecting agent runtimes through built-in adapters, commands, webhooks and external plugins.
Full transcript
Loading transcript…