Dotta on Defining 'Done' for AI Agents and Paperclip's Liveness Model

In the rapidly evolving world of AI and autonomous agents, the concept of "done" is becoming increasingly complex. Dotta, the creator of Paperclip, recently shed light on this critical challenge, presenting hard-earned lessons from developing Paperclip's liveness model. As AI agents generate code and documentation at unprecedented speeds, humans struggle to keep up with verification, risking a new failure mode where agents create more work than can be safely reviewed.

Who Is Dotta?

Dotta is the visionary behind Paperclip, a system designed to manage and ensure the reliability of work done by AI agents. His insights come from practical experience in building agentic systems, focusing on how to define and operationalize the concept of completion in an automated world.

The Nuance of "Done" in Agentic Systems

Dotta argues that "done" is not a simple status update or a green checkmark. Instead, it is a sophisticated "reliance claim" that bundles several critical components. This includes the artifact produced, the standard it adheres to, the evidence of completion, the verifier who checked it, the authority authorizing the next step, the owner holding residual risk, and the specific next action. Flattening this intricate claim into a single status is a dangerous oversimplification that most current agent systems make.

The speaker outlines six levels of "done": Produced, Author-done, Spec-done, Accepted, Accountable, and Operationally proven. Many agent systems prematurely halt at "author-done" and falsely equate it with "accountable." However, exhaustive human verification at high volumes is impractical. While a human can verify a few tasks daily and catch bad assumptions, attempting to review thousands of tasks leads to what Dotta calls "approval theater" rather than genuine assurance.

Balancing Liveness and Assurance

A core challenge in agentic systems is balancing "liveness" with "assurance." Liveness refers to the continuous progression of work without blockers, ensuring tasks are always moving and not stuck in invalid states. Assurance, on the other hand, means establishing enough evidence and verification to permit the next legitimate action. Without assurance, liveness becomes "fast wrongness" or "AI slop," producing low-quality output. Conversely, excessive assurance without liveness creates massive review queues that humans cannot realistically handle.

Dotta emphasizes that a trustworthy agent system must preserve both. The "done" claim acts as the controlled transition between these two critical states, ensuring work is both progressing and reliably verified.

Paperclip's Control System and Key Invariants

Paperclip addresses this balance through a robust control system built on three essential invariants:

• Productive work continues: Agents are designed to keep tasks moving forward efficiently.
• Only real blockers stop work: The system identifies and enforces genuine dependencies, preventing unnecessary delays.
• Infinite loops are bounded: Mechanisms are in place to prevent agents from getting stuck in repetitive, unproductive cycles.

To achieve these invariants, Paperclip employs several mechanisms:

• Clear transitions: Every task heartbeat must lead to a next action, ensuring continuous flow.
• First-class blockers: Dependencies between tasks are explicit and enforced by the control plane.
• Interactions and approvals: Human choices leave an audit trail, providing accountability and oversight.
• Reviewers and approvers: Tasks can be explicitly assigned to human or agent reviewers and approvers (e.g., QA, CTO).
• Watchdogs: These are specialized agents given a goal, tasked with ensuring all other agents work towards its completion, regardless of the underlying harness (Pi, OpenGL, Hermes, Claude Code, Codex, etc.).
• Evidence: Comments, documentation, and work products serve as evidence of completion, not just liveness.
• Child issues: Complex tasks are broken down into smaller, manageable units for better decomposition and tracking.

Treating "Done" as an Object, Not a Boolean

Dotta advises treating "done" as an object rather than a simple boolean. This allows agents to distinguish between the various components of a completion claim: the artifact, scope, standard, evidence, verifier, authority, residual risk, and the next action. Humans often paper over these details, but agentic systems require explicit definitions.

Dotta's Checklist for 100x More Work

For organizations aiming to multiply their output with agents, Dotta offers a practical checklist:

1. Define done levels before agents start: Establish clear stages of completion.
2. Separate verifier from author: Use different models (e.g., Claude for coding, Codex for verification) or agents for distinct roles.
3. Keep blockers explicit: Clearly define dependencies to prevent hidden bottlenecks.
4. Manage allowed next actions: Guide agents on permissible next steps.
5. Require evidence, not just confidence: Equip agents with tools to provide proof of work, such as custom browser harnesses, screenshots, and direct access to browsers for self-verification.
6. Route by risk and reversibility: Implement conditional routing based on the potential impact and ease of undoing a task.
7. Bound recovery loops: Design safeguards to prevent agents from endlessly retrying failed tasks.

Ultimately, Dotta concludes that making "done" specific enough for someone else to safely build on is paramount. The true output multiplier in agentic systems comes after a robust trust protocol is established.