AI Engineer World's Fair 2026

What Does Done Even Mean? Agents and Paperclip's Liveness Model - Dotta, Paperclip

Dotta7:14

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.

Slide lists PR, comment, doc, summary, and approval request beneath the heading, with a warning about receiving work you cannot trust.Open full source frame
Agents are great at finishing the wrong thing.
0:000:11
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

0:00 · section reference included

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:

LevelWhat it establishes
Producer claimThe author says the work is complete.
Independent reviewAnother party finds no obvious issues.
VerificationEvidence meets a specified standard.
ApprovalAn authorized person signs off.
AccountabilitySomeone stands behind the decision.
Real-world outcomeThe 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.

0:501:07
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

0:50 · section reference included

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.

1:492:00
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

1:49 · section reference included

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.

Three numbered statements: productive work continues, only real blockers stop work, and infinite loops are bounded.Open full source frame
Three invariants for the control plane.

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.

3:273:39
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

3:27 · section reference included

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.

Control-system slide with cards for transitions, blockers, approvals, reviewers, watchdogs, evidence, and child issues with plan decomposition.Open full source frame
The control system includes watchdogs, monitors, and recovery.

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.

4:414:58
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

4:41 · section reference included

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.

5:155:27
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

5:15 · section reference included

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:

  1. Specify the completion standard. Decide exactly what the task must establish.
  2. 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.
  3. 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.

Seven-item checklist covering done levels, separate verification, explicit blockers, next actions, evidence, risk and reversibility, and bounded recovery loops.Open full source frame
Separate the verifier from the author and require evidence.
5:566:08
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

5:56 · section reference included

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.

6:406:58
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

6:40 · section reference included

Resources

From the talk

  • Open-source agent orchestration platform with task ownership, execution locks, approvals, budgets and setup instructions.

Updates since the talk

Transcript download
Full transcript

Loading transcript…