Paperclip Liveness Model

The Paperclip Liveness Model is a system that answers "is this AI task actually done?" in a practical way. Its creator, Dotta, explains that programming is now "solved" in the sense that AI agents (automated programs that perform tasks) can produce more code and documentation than any human has time to verify. This creates a new failure mode: agents create more work, not less. Paperclip solves this by treating "done" not as a simple yes/no Boolean (true/false value) but as an object with clear transitions between states. Every task has defined next states, so you know exactly what step comes next and whether progress is real. Paperclip is harness agnostic, meaning it works with any AI tool—Claude Code, Codex, OpenAI, or others—giving you one consistent interface to confirm a goal is complete.

Why does this matter for AI development? Without a liveness model, agents can run endlessly, produce useless output, or silently drift off course. Paperclip provides mechanisms that ensure productive work continues, only real blockers stop work, and infinite loops are bounded. It also defines architectural components like hooks (deterministic code that fires before a tool call or comment) and observability (logs and evals that tell you whether the agent is doing well or quietly drifting). These prevent the agent from forgetting critical steps. By giving you a structured way to verify completion, Paperclip turns AI from a chaotic generator into a reliable worker you can actually trust to finish a job without creating a mess.

Paperclip is a harness-agnostic (works with any AI agent tool) control plane that helps you orchestrate agents toward a clear goal. To use the Paperclip Liveness Model step by step, start by treating “done” not as a simple yes/no Boolean, but as an object with multiple dimensions. For example, a task like “write documentation” isn’t done just because text exists; you need to define success criteria such as “all functions documented, reviewed by a peer, and committed.”

Next, set up a watchdog (a maximizer agent that enforces goal completion) inside Paperclip. This watchdog monitors your primary agents and ensures they keep working until every criterion is met. The watchdog is harness agnostic, so it works with Claude Code, Pi, OpenGL, Hermes, or any other agent tool you prefer.

To make this concrete, imagine you run an agent to build a new feature. Instead of letting the agent declare “done” after writing code, you create a Paperclip task with clear transitions to the next state. The watchdog checks that tests pass, secrets (environment variables for API keys) are stored properly, and the code deploys without errors. If something fails, the watchdog forces the agent to retry or ask for missing input.

Paperclip also provides mechanisms to bound infinite loops and ensure only real blockers stop work. To get started, launch Paperclip from a terminal, configure your project with a design file, and let the watchdog manage your agents until your defined “done” object is fully satisfied.

Use "done" carefully in Paperclip. The creator Dotta warns that agents can now create more code than a human can ever verify, creating a new failure mode. Stop treating "done" as a Boolean (simple true/false value) and instead treat it like an object. This forces you to define what completion actually means in detail.

A key pitfall is losing visibility across multiple agents. When you run many sessions, you often forget which agent is doing what and what you asked them to do. Paperclip solves this with a unified interface. Use watchdogs, which are agents that enforce a goal is completed by other agents. Watchdogs are harness-agnostic (work with any AI framework like Claude Code or Codex), so you get consistent control.

Always set up secrets properly. Paperclip has a built-in secret manager for environment variables and API keys. If you skip this, you risk security exposures. Configure each agent to know where its secrets live.

Set clear task transitions. Every task in Paperclip should have a defined next state. This prevents infinite loops and ensures only real blockers stop work. Set up triggers for schedules, webhooks, or terminal runs so work proceeds automatically.

Finally, use an orchestration agent to manage Paperclip itself. One user created a separate executive-assistant agent with full knowledge of Paperclip's architecture, including its API and heartbeat protocol (signals that check if an agent is alive). This helper agent tracks what's configured and queries status, preventing the confusion that comes from manually tracking everything.