Paperclip AI + Claude Code: Turning Coding Agents Into a Managed Team

The Paperclip AI Claude Code integration is where the whole project started. Paperclip's creator was running an automated trading operation with more than twenty Claude Code tabs open, none of them aware of each other, none of them recoverable after a reboot. Paperclip was the fix: a control plane that hires coding agents, gives them tickets, isolates their workspaces and caps their spend. This guide covers the Claude Code adapter, budgets, workspaces, approvals, a sample org chart for a small development shop, and how Codex, Cursor and OpenCode slot into the same company. New to the platform? Start with the complete Paperclip AI guide.

Why coding agents were the first use case

Claude Code is a terminal-based coding agent. It reads a repository, plans, edits files, runs tests and commits. One instance on one task is excellent. The trouble starts when you want five of them working on the same codebase at once. They step on each other's files, they duplicate effort, they lose all context when the terminal closes, and there is no single place to see what they cost. The creator of Paperclip, the pseudonymous developer known as dotta, hit every one of those problems and built the org-chart-and-ticket model as the answer. That is why the Claude Code adapter is the most mature one in the project and why the official test-drive command defaults to it.

The Claude Code local adapter

The Claude Code adapter runs the Claude Code CLI as a local process on the Paperclip server. On each heartbeat, Paperclip checks out a ticket for the agent, prepares a workspace, launches Claude Code with the ticket, the goal ancestry and the role's instructions, and captures everything the session does: file edits, commands, tool calls, tokens. When the session ends, the result is attached to the ticket and the cost is charged to the agent's budget.

The fastest way to see it in action is the isolated test drive, which needs nothing but an API key:

ANTHROPIC_API_KEY=sk-ant-... npx paperclipai test-drive

That spins up a throwaway company with a Claude Code employee, runs a sample ticket end to end, and shows you the dashboard. Nothing is installed permanently. When you are ready for a real instance, use npx paperclipai onboard --yes or follow our install guide.

API key or Claude subscription?

This is the question we get most. Claude Code can authenticate with an Anthropic API key (pay per token) or with a Claude subscription login. Both work with Paperclip, but they behave differently under management.

	API key	Claude subscription
Cost model	Per token, unbounded	Flat monthly fee, rate limited
Paperclip budget tracking	Accurate per-agent dollar cost	Token counts tracked; dollar cost estimated
Auto-pause at 100 percent	Enforces a real spend ceiling	Enforces a usage ceiling you define
Concurrency	Scales with your account limits	Bounded by subscription rate limits
Best for	Production companies with several agents	Solo builders and evaluation

Our recommendation for anything beyond a single employee is an API key with a conservative per-agent budget. The whole point of Paperclip's cost controls is a hard dollar ceiling, and that only means something when the underlying billing is metered. Full numbers are in our Paperclip AI pricing breakdown.

Workspaces as git worktrees

Paperclip isolates each agent's work using git worktrees and branches. When an engineer agent checks out a ticket, it gets its own worktree on its own branch. Two engineers on two tickets never touch the same working directory. When the work is done, the branch is pushed and the ticket moves to review. This is a small feature with a large effect: it is the thing that makes five Claude Code sessions on one repo safe.

Practical notes:

• Keep the repository on the same machine as Paperclip, or on a fast mounted volume. Worktree creation on a slow network share drags every heartbeat.
• Store the git credential and any deploy keys in Paperclip's encrypted secrets, not in the agent's job description.
• Name branches by ticket. Paperclip does this by default, and it makes the audit trail readable months later.

A sample org chart for a small dev shop

Here is a structure we have seen work for a two-to-five person software business that wants agents to take over the routine half of the backlog.

Role	Adapter	Job	Heartbeat	Budget	Reports to
CTO	Claude Code	Reads backlog, breaks epics into tickets, assigns, reviews PRs	Hourly	$150/mo	Board
Backend Engineer	Claude Code	Implements assigned tickets in the API repo	Task-triggered	$200/mo	CTO
Frontend Engineer	Codex	Implements assigned tickets in the web repo	Task-triggered	$200/mo	CTO
Code Reviewer	Claude Code	Reviews every PR against a checklist, requests changes or approves	Task-triggered	$100/mo	CTO
QA Engineer	OpenCode via OpenRouter	Writes and runs tests on approved branches	Task-triggered	$80/mo	CTO
Release Manager	Bash/process	Merges approved PRs and tags releases, behind an approval gate	Daily	$10/mo	Board

The board is you. Approvals are the important part: in this layout, nothing merges to main without a human approving the Release Manager's ticket. Once the Code Reviewer's judgment proves reliable, you can move the approval gate up a level. How goals, tickets and heartbeats fit together is covered in how Paperclip AI orchestration works.

Approval gates that actually protect you

Paperclip's execution policies let you insert a review stage between a ticket being done and its effect landing. For coding companies we suggest three gates to start:

1. Before merge to a protected branch. Human approval, always, until you have months of clean history.
2. Before any ticket that touches secrets, billing or infrastructure. Tag those tickets and route them to the board.
3. Before a new hire. The CTO agent can propose adding a role; the board approves it. This prevents an agent from expanding the org chart on its own.

Mixing Codex, Cursor and OpenCode in one company

Paperclip is adapter-agnostic, so a single company can employ Claude Code, Codex, Cursor and OpenCode side by side. In practice teams pick per role. Claude Code tends to get the roles that need long, careful reasoning over a large codebase. Codex is common for well-scoped implementation tickets. Cursor's adapter suits teams already living in that editor. OpenCode with an OpenRouter model gives you a cheap QA or documentation role. You can even run the test drive against a different harness to compare:

OPENAI_API_KEY=... npx paperclipai test-drive --harness codex
OPENROUTER_API_KEY=... npx paperclipai test-drive --harness opencode --model openrouter/anthropic/claude-sonnet-4.5

The rest of the integration surface, including Linear sync so your existing issue tracker mirrors Paperclip tickets, is in our Paperclip AI integrations guide.

Reading the dashboard day to day

Once the company is running, the two views that matter are the cost breakdown and the activity log. The cost view shows spend per agent, per project, per provider and per model, so you can see within a day if the Backend Engineer is burning three times its share on a stuck ticket. The activity log shows every tool call each session made, which is the fastest way to understand why a ticket took forty minutes instead of four. Most teams check both once in the morning and once before close, and rely on the Telegram approval notifications the rest of the time. If an agent keeps hitting its budget early, the fix is almost always a better ticket description rather than a bigger budget.

Frequently asked questions

Does Paperclip need an Anthropic API key?

Only if you use the Claude Code adapter with API billing. Paperclip itself has no model dependency. Each agent brings its own provider credentials, stored in Paperclip's encrypted secrets.

Can Claude Code agents in Paperclip work on private repositories?

Yes. Store the git credential or deploy key as a secret and grant it to the role. Each agent works in its own git worktree on the Paperclip server.

How many Claude Code agents can one Paperclip server run?

It depends on the server and your provider rate limits, not on Paperclip. A modest VPS handles a handful of concurrent sessions comfortably. Scale the machine before you scale the org chart.

What happens if a Claude Code session crashes mid-ticket?

The ticket stays checked out with a timestamp and payload in the audit log. Paperclip can reassign it on the next heartbeat, and the worktree is left in place for inspection.

Is this only for software companies?

No. Coding agents are the most mature adapter, but Paperclip's structure applies to any recurring knowledge work. See our post on Paperclip AI use cases and templates.