Vietnamese
Japanese
EnglishInside Paperclip — How an "AI Company" Runs From the First Command
Fujigo Software Solutions
Member of M&C Holdings (Japan)
In 2026, running one AI agent is easy. Running 10 agents at once without anyone stepping on anyone else’s toes — that’s the real problem. In our previous article, we described Paperclip as a kind of “company” that manages AI agents. But concretely, how does that company operate — from the moment you start the server to the moment the first agent begins working?
Control plane — Paperclip doesn’t run AI, it organizes AI
Many people hear “AI platform” and picture a system that calls APIs, processes prompts, and trains models. Paperclip does none of those things.
Paperclip is a control plane — the orchestration layer that decides who-does-what, when, and with-how-much-budget. It doesn’t call the OpenAI API or the Anthropic API directly. It doesn’t write code. It manages the entities that write code.
Think of it this way: the CEO of a software company doesn’t sit and code. The CEO assigns tasks, tracks progress, reviews results, and controls costs. Paperclip does exactly that — but for AI agents.
Each agent runs on its own adapter: Claude Code, Codex, or whichever LLM you choose. The adapter is where the executing “muscle” lives. Paperclip merely assigns tasks, tracks state, records costs, and ensures nobody strays from their mission.
Control plane = the organizing brain. Adapter = the executing muscle. Keeping these two things separate is the single most important design decision in Paperclip.
Heartbeat — Why agents don’t run continuously
You hire 5 AI agents. All 5 run continuously, 24/7, calling the API every minute, burning tokens every minute. At the end of the month, the bill arrives — and you have no idea where that $800 went.
Paperclip solves this with the heartbeat — an “alarm clock” mechanism for agents.
Instead of running continuously, each agent sits in a sleeping state. When its turn comes (or when a new event occurs), Paperclip wakes the agent. The agent wakes up, checks whether there’s any task to do, does the work, reports the result, then goes back to sleep. This cycle repeats.
Each wake-up is called a heartbeat. And every heartbeat has an audit trail: which agent woke up, what it did, how many tokens it spent, and for how long.
Paperclip supports two ways of waking:
- Interval — wake on a recurring schedule (for example: check for new tasks every 10 minutes)
- Event-driven — wake the instant something happens: a new task is assigned, a new comment appears, or an approval was just granted
Why does this matter? Because every time an agent wakes up it costs money — tokens sent, tokens received, every API call has a price. The heartbeat ensures an agent only spends money when there is genuinely work to do. No infinite loops. No surprise bills. Every dollar traces back to the right task, the right agent, the right moment.
Org chart — CEO, CTO, Engineer: not just a metaphor
In the introductory article, we posed a question: if you have 20 agents and nobody manages them, what happens? Chaos.
Paperclip organizes agents into a hierarchy just like a real company. The CEO agent sits at the top and assigns tasks down to the CTO. The CTO analyzes, breaks things down, and communicates down to the Engineer agents. Once an Engineer finishes coding, it reports back up. This isn’t a nice metaphor — it’s a real mechanism with real authority.
The chain of command works in the reverse direction too: when an Engineer agent gets stuck (missing context, an unclear task, an unexpected error), it doesn’t stay silent. It automatically escalates to the CTO. The CTO handles it or escalates further to the CEO. The CEO can escalate to the Board — the real humans behind the system.
Authority is also clearly tiered. Not every agent is allowed to create a new agent. Not every agent is allowed to approve code or merge a pull request. Each role has boundaries, and Paperclip enforces those boundaries automatically.
The result: you always know who reports to whom. When something goes wrong, you know exactly which agent is responsible, and which manager should have caught the error sooner.
20 agents with an org chart = a disciplined team. 20 agents without an org chart = 20 entities operating in disarray.
Task lifecycle — From backlog to done: 7 states, 0 tasks slip through
Every task in Paperclip moves through a lifecycle of 7 states: backlog → todo → in_progress → in_review → done. Plus two special states: blocked (waiting on someone) and cancelled.
The most important mechanism here is atomic checkout. Before starting work on a task, an agent must “check it out” — just like checking out a branch in Git. If another agent has already checked out that task, the system returns a 409 Conflict error. An agent that receives a 409 knows immediately: this task is already taken, move on to another. No retry. No contention.
The result: two agents never do the same job twice.
Every action within a heartbeat is tied to a run ID — the identifier of that wake-up. Who checked out which task, who commented what, at what time — all of it is traceable. This is an automatic audit trail, with no need for a developer to log anything by hand.
Let’s walk through a quick example: the Board creates the task “Fix bug login timeout.” The CTO receives a heartbeat, sees the new task, checks it out, analyzes it, and creates a subtask assigned to an Engineer. The Engineer receives the next heartbeat, checks out the subtask, reads the code, fixes the bug, commits, and comments the result. The CTO receives a later heartbeat, reviews the code, and approves. The task moves to done. Throughout the whole process — not a single step is skipped.
Real-time cost tracking — Every token counted, every cent recorded
When you run many agents, API costs climb fast. And the hardest question isn’t “how much did it cost?” but “where did it cost?”
Paperclip answers that question with real-time cost tracking. Each agent has a monthly budget. When an agent spends 80% of its budget, the system sends a warning. At 100%, Paperclip automatically pauses the agent — no human has to remember to check; the system enforces it itself.
The dashboard shows costs by agent, by task, by time period. You know exactly which task that $3.50 went into, which agent ran, at what time, and across how many heartbeats.
Compare that with the common approach today: most teams running AI agents only ever see the total API bill at month’s end, with no idea which feature $50 of it went into, which agent spent the most, or which task “burned money” because an agent looped. Paperclip gives you the answer down to the individual task, the individual heartbeat.
No estimates. No “roughly.” Real numbers, in real time.
Demo walkthrough — 1 task through the system from start to finish
To see everything working together, let’s follow one concrete task:
Step 1: The Board (a human) creates the task “Write API endpoint /users” in Paperclip. Assigns it to the CTO agent.
Step 2: The CTO receives a heartbeat. Checks the inbox — sees the new task. Checks out the task (status moves from todo → in_progress). The CTO reads the brief, analyzes the scope, and decides an Engineer is needed. Creates the subtask “Implement GET /users with pagination,” assigns it to an Engineer agent.
Step 3: The Engineer receives the next heartbeat. Checks out the subtask. Reads the codebase, writes the code, runs the tests, commits. Comments on the task: “Done. Added pagination with cursor-based approach. Tests passing.” Cost of this heartbeat: $1.20.
Step 4: The CTO receives the next heartbeat. Sees that the Engineer has commented. Reviews the code, checks the test results, verifies there are no security issues. Approves. Marks the subtask done. Marks the parent task done.
Step 5: The Board opens the dashboard. Task done. Total cost: $2.30 (3 heartbeats — 1 CTO assigning, 1 Engineer coding, 1 CTO reviewing). The audit log records every step in full. Not a single step was skipped, and no agent operated outside its scope.
The whole process is automatic. But the Board still stays in control: they create the task, they set the budget, and if needed — they approve before code is merged. This is the difference between “automatic” and “out of control”: agents run on their own, but humans decide when agents are allowed to run and how far their scope extends.
Next up: install Paperclip in 15 minutes
You’ve now seen how Paperclip operates on the inside: the control plane orchestrates, the heartbeat keeps discipline, the org chart divides authority, the task lifecycle ensures no one duplicates work, and cost tracking keeps the budget in check. In the next article, you’ll install Paperclip with your own hands — from an empty terminal to your first agent running a heartbeat, in 15 minutes.