Turning a team of AI agents into an autonomous 'company' with goals, budgets, and an org chart
Paperclip — orchestration for autonomous AI 'companies'
An open-source platform (Paperclip, which I fork and contribute to) that turns a team of AI agents into a 'company' with a goal, an org chart, budgets, governance, and an immutable audit log. If OpenClaw is an employee, Paperclip is the company.
One AI agent can do a task — but getting a team of them to run a real process together, on budget, without going off-strategy or quietly stopping, has mostly stayed a lab problem. Every team that tries glues together its own coordination layer; most collapse under their own weight.
Paperclip — an open-source orchestration platform that gives AI agents an org chart, named roles, monthly budgets, an immutable audit log, and a board (you) that can override anything. If OpenClaw is the employee, Paperclip is the company.
| Before | After | |
|---|---|---|
| Coordinating many agents | a research topic, impressive in demos | a runtime you can run concrete companies on |
| Keeping agents on task | they drift, loop, or lose the goal | an org chart and a CEO hold the group to one objective |
| Cost control | runaway token spend, no ceiling | monthly budget per agent — they stop when they hit it |
| Auditability | good luck reconstructing what happened | every tool call traced, full immutable log |
| Running more than one company | another stack from scratch each time | one deployment, many companies, full data isolation |
| Human involvement | constant supervision, step by step | you're the board — approve hires, set budgets, override |
What used to be a demo you watched is a runtime you can run actual companies on — one or many in parallel, each with its own data isolation, each visible from one control plane. The Growth Agency case (five agents running BetterStory's marketing) is one company built on this. The runtime is the platform that makes that kind of thing safe enough to leave running.
What I built
I work on Paperclip — an open-source orchestration platform for autonomous AI "companies." It's a Node.js + React runtime that takes a team of AI agents and turns them into a working organization with goals, budgets, governance, and an org chart. I fork it locally, contribute, and run concrete companies on it.
The framing the project itself uses is the cleanest summary: if OpenClaw is an employee, Paperclip is the company. A single agent does work; a team of them needs structure to stay coordinated. Paperclip is that structure.
- An org chart, not just a group of agents. Each agent has a named role and a manager. A CEO agent owns strategy, assigns work, and reviews output. Specialists execute. Work flows up and down the chart on heartbeats.
- Bring your own agent runtime. OpenClaw, Claude Code, Codex, Cursor, raw HTTP — Paperclip doesn't care what's behind the agent, as long as it can receive a heartbeat. One org chart, many runtimes.
- Hard budgets per agent. Every agent has a monthly budget. The runtime stops them at the ceiling. A single rogue planning loop can't blow the month.
- Multi-company. One deployment, many companies, complete data isolation. One control plane for a portfolio of autonomous orgs.
- Immutable audit log. Every conversation, every tool call, every decision is traced. The system stays explainable even when most of the work is done without you touching it.
- You sit as the board. Approve hires, override strategy, pause or terminate any agent at any time.
The Growth Agency case (five agents running BetterStory's marketing) is one concrete company running on this. The platform is what makes building more of them a matter of configuration instead of building a coordination layer from scratch.
Why it matters
The pitch of "an autonomous AI company" is easy to make in a demo and hard to make in production. Most multi-agent setups work right up until they drift off-strategy, blow a budget, or quietly stop producing — and the reason they fail is almost always the same: there's no organizing structure holding them to a goal, no hard ceiling on what they can spend, no audit trail when something goes wrong. Paperclip borrows the answer that human organizations spent a century working out — an org chart with a CEO and bounded roles — and adds the things software can do that orgs can't: hard budget ceilings, immutable audit, multi-company isolation.
It's also a measuring stick. The amount of human steering this runtime needs keeps dropping as the underlying models get more capable, so running concrete companies on it (like the Growth Agency) is a way to see exactly where the frontier of autonomous coordination sits right now — and where it's heading next. Knowing that firsthand, instead of guessing from a demo reel, is half the point of the work.
The hard part of multi-agent work isn't getting one agent to do a task — it's getting a group of them to stay coordinated without unraveling. Left alone, agent teams drift, second-guess each other, or quietly lose the goal a few hand-offs in. Paperclip's answer is to import the organizing primitive that solves this in human companies: an org chart, with a CEO that owns strategy and roles that own execution. The runtime then adds the things software can do that organizations can't: hard budget ceilings per agent, immutable audit logs, full tool-call tracing, multi-company isolation. That combination — borrowed organizational structure plus software guardrails — is what turns "a team of agents talking to each other" into something you can leave running and trust to behave.
Paperclip is the part of the story that makes the rest of it operable: a runtime where many agents become a company with goals, budgets, and governance — not just a clever multi-agent demo. The Growth Agency that runs my own marketing is one company built on it; the platform is what makes building more of them a matter of configuration instead of starting from scratch.