Paperclip: the org chart your AI agents are missing
Most teams scaling AI agents add more agents. The evidence says that makes things worse. Coordination overhead compounds faster than the parallelism benefit, and somewhere past three to four concurrent agents, you hit a saturation point where the system actively fights itself. If you’re managing a fleet of coding agents and wondering why context keeps bleeding and costs keep climbing, the problem isn’t your models. It’s the absence of structure.
TL;DR: Paperclip is an open-source orchestration layer that imposes org-chart hierarchy, per-agent budgets, and immutable audit logs on multi-agent AI systems. Where most frameworks treat coordination as a graph or conversation problem, Paperclip treats it as a management problem, with strict task ownership, goal ancestry, and human override built in.

Why do multi-agent systems actually fail?
The MAST taxonomy (March 2025), built from 1,642 annotated execution traces across seven popular open-source multi-agent frameworks, puts a number on something most teams only feel: roughly a third of multi-agent failures are inter-agent misalignment. These are coordination failures, not model failures: tasks claimed by two agents, context lost between handoffs, subtasks completing in the wrong order.
The same study measured failure rates between 41% and 86.7% across those seven frameworks (arXiv:2503.13657). The other two failure categories it identifies, system design issues and weak task verification, are also properties of the system around the model rather than of the model itself.
Think about what happens when you put 100 soloists in a room and ask them to play a symphony. They’re individually excellent. Without a conductor, a score, and section leads, the output is noise. Multi-agent systems fail the same way. The models aren’t the bottleneck. The missing conductor is.
A December 2025 Google-led study of 260 agent configurations (arXiv:2512.08296) found that under a fixed compute budget, per-agent reasoning becomes too thin beyond three to four agents, and that coordination brings diminishing returns once a single agent is already strong on the task. Past that point, more agents mostly add communication cost.
What does Paperclip do differently?
Paperclip models an AI system as a company-as-graph: a strict tree hierarchy where every agent reports to a manager agent, and every task traces ancestry back to a company-level mission. That ancestry is load-bearing. An agent can always answer “why am I doing this?” by walking the goal tree. The MIT-licensed repository launched in March 2026 and passed 110,000 GitHub stars by November 2026.
graph TD
A[Company Mission] --> B[Engineering Manager]
A --> C[QA Manager]
B --> D[Agent: Backend Dev]
B --> E[Agent: Frontend Dev]
C --> F[Agent: Test Writer]
C --> G[Agent: Security Scanner]
D -.->|reports to| B
E -.->|reports to| B
F -.->|reports to| C
G -.->|reports to| C
style A fill:#1a1a2e,stroke:#e94560,color:#fff
style B fill:#16213e,stroke:#0f3460,color:#fff
style C fill:#16213e,stroke:#0f3460,color:#fff
style D fill:#0f3460,stroke:#533483,color:#fff
style E fill:#0f3460,stroke:#533483,color:#fff
style F fill:#0f3460,stroke:#533483,color:#fff
style G fill:#0f3460,stroke:#533483,color:#fff
The coordination model is atomic task checkout. One agent owns a task until it’s done or explicitly released. No two agents work on the same item. Agents wake on scheduled heartbeats or on events such as a task assignment or an @-mention, and resume the same task context each time. This is distributed systems hygiene that most agent frameworks leave to you.
Where LangGraph gives you a graph and CrewAI gives you roles, Paperclip gives you a reporting structure. That distinction matters at scale. For the broader taxonomy, see agent orchestration patterns.
How does agent governance prevent cost spirals?
Gartner projects that over 40% of agentic AI projects will be canceled by end of 2027 (Gartner, June 2025). That isn’t a technology failure prediction. It’s an economics prediction. Teams that can’t see what their agents are spending, can’t justify the spend, and can’t course-correct fast enough end up killing the project.
Paperclip addresses this with three governance primitives baked into the core. Per-agent budgets set monthly ceilings per agent. When an agent hits its ceiling, it stops instead of burning through quota silently. Immutable audit logs capture every tool call at the individual agent level. Approval gates keep a human in charge: you approve new agent hires and can override strategy, pause or terminate any single agent without stopping the whole system. For deciding which actions deserve a human gate, see why human-in-the-loop beats full autonomy for high-stakes actions.
| Dimension | Ungoverned agents | Paperclip-governed agents |
|---|---|---|
| Cost visibility | Per-API-key aggregate | Per-agent monthly budget |
| Task ownership | First-come, first-served | Atomic checkout, one owner |
| Audit trail | Scattered logs | Immutable, tool-call level |
| Human override | Kill the process | Pause, resume, reassign |
| Context across sessions | Lost on reboot | Persistent state store |
The persistent state store is underrated. Most teams lose agent context every time a session ends. Locally, Paperclip keeps state in an embedded PostgreSQL database (production deployments point it at their own Postgres), and agents resume the same task context across heartbeats and reboots instead of starting from scratch. For patterns on securing agent workloads, see securing agent orchestration.
Where does Paperclip fit in the agent framework landscape?
Paperclip is not a framework. It’s an orchestration layer that sits above your existing agent runtimes. The design philosophy is BYOA (Bring Your Own Agent). As of April 2026, Paperclip ships adapters for Claude Code, Codex, Cursor, Gemini, OpenCode, OpenClaw and Pi, plus generic process (shell) and HTTP adapters, so any agent that can receive a heartbeat over HTTP can plug in. Paperclip manages the org chart, the budgets, and the audit trail; your agents do the work.
| Capability | LangGraph | CrewAI | AutoGen | Paperclip |
|---|---|---|---|---|
| Primary model | Graph workflows | Role-based teams | Conversations | Org hierarchy |
| State persistence | Checkpoints | Opt-in (Flows) | Opt-in (save/load state) | Embedded Postgres |
| Budget control | Manual | None built in | Token-usage termination | Per-agent limits |
| Audit logging | Via LangSmith | Basic | Basic | Immutable, built-in |
| Agent runtime | Python, JS | Python | Python, .NET | Any (adapters) |
| Governance | Add-on | None | None | Core feature |
The runtime portability is the real differentiator. LangGraph, CrewAI, and AutoGen expect you to write your agents inside the framework. (Microsoft has since made its Agent Framework the successor to AutoGen; the SDK decision framework compares the first-party options.) Paperclip assumes nothing about your agent implementation. It requires that each agent can receive tasks and report status. That opens the door to heterogeneous fleets: a Cursor agent handling UI, a Codex agent handling tests, a custom shell agent handling deployments, all under one governance umbrella.
For a broader taxonomy of coordination approaches, see multi-agent architectures.
When should you not use multi-agent orchestration?
Multi-agent orchestration carries a coordination tax that single-agent execution does not. Anthropic reported in June 2025 that its multi-agent research system used about 15x the tokens of a chat interaction, against about 4x for a single agent. That’s before you factor in debugging overhead and failure recovery.
The honest decision framework: add agents only when the parallelism benefit exceeds the coordination tax. Parallelism helps when tasks are genuinely independent: different repos, different services, different output types. It hurts when tasks share state, require tight sequencing, or need frequent context exchange.
In McKinsey’s State of AI survey (November 2025), 23% of respondents said their organizations were scaling an agentic AI system somewhere in the enterprise, and another 39% were experimenting with agents. Teams moving out of the experimental phase should not assume multi-agent beats single-agent. It’s only better when the work is parallelizable.
If you’re running three agents against the same codebase with overlapping concerns, you don’t need orchestration. You need better task decomposition. Start there. See scaling multi-agent systems for when parallelism actually pays off.
Key takeaways
- Coordination failures account for roughly a third of multi-agent system failures according to the MAST taxonomy, not model quality failures
- Under a fixed compute budget, one Google-led study found per-agent reasoning thins out beyond three to four agents, so adding more mostly adds communication cost
- Paperclip imposes strict org-chart hierarchy, atomic task ownership, and per-agent token budgets on any agent runtime
- The persistent state store (embedded PostgreSQL) solves session-boundary context loss that most frameworks ignore
- Multi-agent orchestration only justifies its coordination tax when tasks are genuinely parallelizable
FAQ
Is Paperclip an agent framework?
No. Paperclip is an orchestration layer, not a framework. It manages org structure, task routing, budgets, and audit logs above whatever agents you bring. You can use Claude, Cursor, Codex, Gemini, or any HTTP-compatible runtime. Paperclip coordinates them; it doesn’t replace them.
How does Paperclip handle cost control?
Each agent gets a configurable monthly budget. When an agent hits its limit, Paperclip stops it instead of letting it keep spending. Combined with tool-call-level tracing and an immutable audit log, this gives you per-agent cost attribution rather than one blended total per API key.
Can I use Paperclip with agents other than Claude?
Yes. As of April 2026, Paperclip ships adapters for Claude Code, Codex, Cursor, Gemini, OpenCode, OpenClaw and Pi, plus generic process (shell) and HTTP adapters, so any agent that can receive a heartbeat over HTTP can join a Paperclip org. Runtime homogeneity is not required.
When is multi-agent orchestration overkill?
When tasks share state, require tight sequencing, or need frequent context exchange between agents, single-agent execution usually wins. Multi-agent setups also cost more tokens: Anthropic reported in June 2025 that its multi-agent research system used about 15x the tokens of a chat interaction, against about 4x for a single agent. Orchestration earns its overhead only when work is genuinely parallelizable across independent domains.