Paperclip and Claude Code: How to Run a Company of AI Agents

Running eight terminals at once tells you almost nothing. It shows you eight cursors blinking and eight task names you are supposed to remember, with no shared goal between them and no record of what each one decided when you were not watching. That gap between "multiple sessions running" and "an organization that executes" is exactly what Paperclip closes. It is a free, MIT-licensed open-source tool that adds a layer of structure to Claude Code so agents form an actual org chart, with a shared mission, defined roles, a ticket system, budget caps, and approval gates. The result is something closer to managing a company than managing a terminal window.

Here are eight specific capabilities Paperclip adds that running separate Claude Code sessions in isolation cannot give you.

1. A shared company mission so every agent acts from the same goal, not its own isolated context

When you open several Claude Code sessions and assign tasks to each one, each session starts fresh. There is no memory of what the others are doing, no awareness of the overarching goal, and no way to know whether a decision made in one session conflicts with work happening in another. The agents do not know each other exist.

Paperclip changes that by giving every agent inside a company a shared foundation. You define the company mission once, and every agent hired into that company has access to it as part of its core context. A researcher and a marketer both know what the business is trying to accomplish and orient their work accordingly. When the CEO agent hires a new engineer, that engineer starts with the same mission context, not a blank slate. This is the difference between a collection of tools and an organization. Tools do their job. An organization coordinates. The shared mission is what makes coordination possible at the agent level without constant manual oversight from the person running it.

2. Heartbeats that wake each agent on a schedule and keep work moving without your presence

A Claude Code session you open manually requires you to be there. When you close the terminal or step away, the work stops. For structured back-office tasks, research compilation, invoice processing, nightly reconciliation, that dependency on your active presence is the main bottleneck. You become the clock for every task that needs to run repeatedly.

Heartbeats solve this. Each agent in Paperclip has a heartbeat file that triggers on a schedule you define. When the heartbeat fires, the agent wakes up, re-reads its current task list, refreshes its context, and keeps working. It does not wait for you to open a terminal. It does not require a prompt from you. It wakes, checks, and moves. For a research agent that needs to pull the latest competitor pricing every morning, or a reconciliation agent that needs to process yesterday's invoices before the team arrives, the heartbeat means the work has already happened before anyone sits down. That shift from "I need to trigger it" to "it ran while I was sleeping" is the operational change that makes multi-agent companies practically useful rather than just interesting in a demo.

3. A ticket system that logs every agent decision so you can read what it was thinking and comment inline

One of the real frustrations with running autonomous AI agents is the trust problem. You can give an agent a goal and let it run, but you have no record of what it decided along the way or why. When a result looks wrong, you have nothing to debug against. And when a result looks right, you cannot replicate the reasoning because the session is gone.

Paperclip tracks everything as tickets. Every conversation, every issue, every decision an agent makes is logged and visible. You can open any ticket, read the agent's reasoning step by step, leave a comment, and approve or reject the work from your inbox. The ticket system turns a black box into a transparent process. For a business owner or manager who needs to trust but verify, this is the mechanism that makes it practical to hand off real work rather than just toy tasks. You are not blindly trusting the output. You are reviewing a record of how the output was produced, which is exactly how you would oversee a new human employee doing the same work.

4. Per-agent monthly budget caps so costs stay predictable as the org grows

An agent company that runs on heartbeats and works around the clock can accumulate token costs quickly, especially if an agent gets stuck in a loop, generates large outputs repeatedly, or takes on more tasks than you anticipated. Without a cap, a badly calibrated agent can produce a surprisingly large API bill before you notice.

Paperclip adds per-agent monthly budget caps that address this directly. You set a spending limit for each agent individually, and the agent operates within that envelope. A researcher that should cost roughly forty dollars a month will not suddenly cost four hundred because it ran an unexpected loop. A marketing agent assigned to a small project gets a cap appropriate to that project. As the org chart grows and more agents are hired, each new agent gets its own cap, so total monthly cost stays within a range you can predict and plan for. This is the financial control layer that makes it safe to let agents run autonomously without a constant eye on the usage dashboard.

5. Board approval gates that stop new hires and risky actions before they run

Autonomous agents that can hire other agents create an obvious concern: the org can expand in ways you did not authorize. A CEO agent executing on a goal might determine that it needs three more specialized agents and hire them immediately, accruing their setup costs and context without anyone checking whether that expansion makes sense.

Board approval gates give you a veto at the organizational level. You configure Paperclip to require your approval before any new agent is hired, or before any action above a defined risk threshold runs. The agent proposes the hire or the action, and your inbox shows the pending request with the reasoning behind it. You approve or decline, and only then does execution proceed. This is a standard governance mechanism applied to AI organizations. You are the board. New headcount requires board sign-off. Risky moves require board sign-off. The company does not act unilaterally on decisions that change its structure or scope. That check keeps you genuinely in control of the org you built rather than watching it evolve in ways you did not intend.

6. Skill repos that add a new capability to an agent in one paste

Building new capabilities into a Claude Code agent normally requires editing instructions, adding context, sometimes restructuring the whole session. There is no clean package format for adding a skill, so the process is ad hoc and hard to replicate or share.

Paperclip introduces skill repos as a standard unit. A skill is a packaged capability that lives in a repository, and adding it to an agent is a single paste. You copy the repo URL into the skill field, and the agent gains the capability immediately. Security scanning, front-end design patterns, data extraction logic, email formatting conventions, these can each live as a skill that any agent in the company can receive. Because skills are repo-based and URL-shareable, the community of Paperclip users can publish and reuse them. When your reconciliation agent needs to handle a new document format, you find or build the skill and add it. The org chart gains competencies at the speed of a paste, not the speed of a rebuild.

7. Pre-built company templates that start the org at 50 percent done

Starting an agent company from scratch means making every structural decision yourself: which roles to create, what each role's instructions should contain, how agents should relate to each other, which skills each needs at baseline. That cold start is the highest friction point for someone new to running agent orgs. Most of the thinking required has already been done by someone who built a similar company structure before.

Paperclip addresses this with pre-built company templates. A template packages an agent team with their roles, instructions, knowledge, and baseline skills already configured. You import the template and the org starts at roughly half built rather than at zero. For a founder testing a new business idea with an AI-first team, importing a template and adjusting the mission and role descriptions takes a fraction of the time that building from scratch would. For someone setting up an accounting back-office, a marketing department, or a research function, the template gives them a starting structure that has already worked for others. The cold start problem is largely solved before they write a single instruction file.

8. A multi-company structure so separate projects or clients never mix context

The most practical limitation of running a single agent company is that all context lives in one place. If you use the same agent org for two separate businesses, or for two separate client projects, context from one can bleed into the other. The agents do not automatically know which context applies to which task, and the boundary between projects becomes something you manage manually rather than something the system enforces architecturally.

Paperclip supports multiple companies inside a single instance, each with fully separate context, mission, agents, and budget. A freelancer running three client projects stands up three companies. An agency with multiple brands runs each brand as its own company. A founder testing two separate business ideas uses two companies without either knowing the other exists. Mixing client data or project strategies inside a shared agent org can produce outputs that reference the wrong business, reveal one client's information in another's deliverables, or apply the wrong goal to the wrong task. Separate companies prevent all of that by design.

An accounting firm in tax season: what the numbers actually look like

A small accounting firm is an unusually clear case for a Paperclip agent company because the work during peak season is high-volume, structured, and deadline-driven in ways that map cleanly onto what agents do well.

Here is the setup. The firm runs Paperclip with a CEO agent and four operational agents. The data agent pulls invoices and receipts from a client email folder each morning, extracting vendor, amount, and date from each document. The reconciliation agent matches those extracts against the relevant client's chart of accounts, flags anything that does not match cleanly, and queues anomalies for human review. The reporting agent compiles each client's monthly summary once reconciliation passes a completeness check. The QA agent runs a nightly pass before anything is marked ready for the partner, checking that no summary references a missing document and that no line items fall outside expected ranges for that client category.

Before running this setup, one staff member spends approximately three hours per day during a four-month busy season on data hygiene and report compilation. That is 80 working days at 3 hours per day for a total of 240 hours across the year where a qualified employee is doing work that could run automatically.

After the agent company takes over, that staff member spends roughly 30 minutes per day reviewing agent output, approving clean reports, and handling the flagged anomalies that genuinely need a human judgment call. Time recovered: 2.5 hours per day for 80 days equals 200 hours per year. At a $32 per hour billing equivalent for that role, the recovered staff capacity is worth $6,400. The monthly token cost for the four-agent company during peak season runs under $40 based on typical structured document volumes at this scale. Annual cost across the four-month peak: under $200. The return on that $200 is $6,400 in recovered staff capacity, a 32x multiple before counting any revenue upside from the staff member's redirected time.

The QA agent running the nightly check also catches the kind of errors that a tired human reviewer misses at hour seven of a long day, which has a risk-reduction value on top of the efficiency gain. For an accounting firm where a miscategorized line item can have real consequences for a client, that consistency has direct quality value beyond the time saving. Setting up the QA layer to flag anomalies before they reach the partner is not just an efficiency move. It is a risk management move built into the system architecture so it runs every night whether anyone remembers to schedule it or not.

The Paperclip model also scales more naturally than a human staffing model when volume spikes. During busy season, the agents absorb the increase without requiring overtime or temporary hires. The incremental cost of processing one more client's invoices through the agent pipeline is a small number of tokens, not an extra shift or an expanded staff. For a firm that wants to grow its client base without proportionally growing its headcount, that scalability is one of the clearest structural advantages of an agent-based back office.