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.
A research demo of agents coordinating → a runtime you can actually run concrete companies on (like the five-agent Growth Agency that runs my own marketing).
| 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.
- 01Define the company
Set the goal of the autonomous company in plain English — *'grow this product to X by Y,'* *'run my marketing.'* The whole org charts back to it.
- 02Hire the team
Assign agents to roles in the org chart. Bring whichever runtimes you want — OpenClaw, Claude Code, Codex, Cursor — they're interchangeable as long as they can receive a heartbeat.
- 03Set budgets
Each agent gets a monthly budget. The runtime hard-stops them at the ceiling, so a single rogue agent can't blow the month's spend on a planning loop.
- 04Run it
The CEO agent assigns work, specialists execute, work flows up and down the org chart on heartbeats. You watch it run from one dashboard, approve hires, override strategy, pause any agent.
- 05Audit
Every conversation, every tool call, every decision is logged immutably. The system stays explainable even when most of the work is done without you touching it.
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.