Paperclip AI Agent Pricing: Free Software, Real Model Costs
Paperclip is MIT-licensed and free to self-host, but model usage isn't. Here's how its budget caps and spending alerts actually work.
What does Paperclip actually cost?
Paperclip, the open-source platform for managing teams of AI coding agents, is free under the MIT license. You can self-host it with no licensing fee and no subscription to the tool itself. What isn’t free is everything Paperclip orchestrates: the Claude Code, Codex, Gemini CLI, or other agent runtimes doing the actual work. Those run on your existing subscriptions or API keys, and that’s where the real cost of running a multi-agent setup shows up.
TL;DR
- Paperclip itself costs nothing to run, it’s MIT-licensed and self-hosted, with a quick local setup using an embedded Postgres database so you don’t need a separate server.
- Model usage is billed separately through whatever adapter you connect (Claude Code, Codex, Gemini CLI, cursor, open code, pi), either via existing subscription logins or API keys depending on the adapter.
- Budgets can be set at the company, agent, or project level, with configurable warning thresholds and hard stops so spending doesn’t run unchecked.
- Budget enforcement isn’t instant, it relies on reported usage data, so work already in progress can push actual spend slightly past a configured cap.
- Heartbeats and routines add usage too, timer-based agent check-ins are off by default, which avoids paying for agents that wake up and find nothing to do.
- A reviewer agent bouncing work back to an implementer multiplies cost, even on a simple project, because every round trip is more model usage.
- The sensible approach is to run one small task first, check the actual spend, and size budgets for the rest of the team from that real number rather than guessing upfront.
Remy is new. The platform isn't.
Remy is the latest expression of years of platform work. Not a hastily wrapped LLM.
How does the free self-hosting model work?
Paperclip runs as software you install and operate yourself. The documented quick-start uses a single command, npx paperclip-ai@latest onboard, which pulls defaults and starts the platform locally with an embedded Postgres database. That means no separate database setup for a first run, and no cost tied to running Paperclip’s own infrastructure.
What you do need is Node.js (version 24.11 or newer) and the agent runtime you plan to connect. If you’re using a local Claude Code or Codex adapter, that CLI has to be installed and authenticated on the same machine. Notably, you don’t necessarily need to buy separate API access: the adapter documentation supports logging in with an existing subscription for some tools, as well as API key setups. Which one gets used depends on the specific adapter and how you configure it, so it’s worth checking before you start assigning tasks to a team.
This is the core of why Paperclip is “free”: it’s a coordination layer sitting above agents you already have access to. It assigns tasks, tracks handoffs, and keeps a record of what happened, but it doesn’t do the coding or reasoning itself. That work still runs through Claude Code, Codex, or whichever runtime you’ve wired in, and those have their own cost structures entirely outside Paperclip’s control.
Where do the hidden costs come from?
The obvious cost is model usage per task. The less obvious cost is how multi-agent workflows multiply that usage. A single coordinator delegating to an implementer and a reviewer means at least three agents touching a piece of work before it’s marked done, and a reviewer sending changes back to the implementer adds another round of usage on top of that. For a genuinely small project, like a basic notes app with create, edit, delete, and persistent storage, the coordination overhead of multiple agents reviewing and revising each other’s output can add up faster than running one agent directly.
Routines add a second layer. These are scheduled or webhook-triggered jobs, like an agent generating a weekly summary of completed work or checking incoming issues every morning. Each execution is tracked work you can inspect afterward, which is useful for accountability, but it’s also usage that happens automatically on a schedule rather than only when you explicitly ask for it.
Heartbeats are a third factor, and Paperclip’s default setting here works in your favor. Heartbeats are what wake an agent to let it work, triggered by assignments, comments, or a configured interval. Timer-based heartbeats are off by default for new agents. That matters because an agent that wakes every few minutes just to find no task waiting is spending compute (and money) for nothing. Leaving that off unless there’s a specific reason an agent needs to check in regularly avoids a quiet source of waste.
How do Paperclip’s budget controls work?
Other agents ship a demo. Remy ships an app.
Real backend. Real database. Real auth. Real plumbing. Remy has it all.
Paperclip lets you track reported spending and set budgets at the company, agent, or project level. Alongside that, you can configure warning thresholds and hard stops, giving you a way to decide where work should pause rather than letting a team of agents run indefinitely against a bill you haven’t checked.
The important caveat is how enforcement actually happens. Budget stops rely on recorded spending and usage reporting, not a real-time meter. That means work already in progress when a threshold is hit can continue briefly before the stop takes effect. In practice, this means a configured budget cap is a strong guardrail, not a guarantee that your provider bill will land on that exact number. Treat it as a ceiling with a bit of give, not a hard wall.
A practical way to use this: run one small, well-scoped task first and look at what it actually costs before setting a budget for a larger team. The amount you spend depends heavily on the models chosen and how much back-and-forth happens between agents, so a single test run gives you a far more realistic number than estimating in advance.
Is Paperclip worth it for the cost?
That depends on what you’re already doing. If you’re running several agents on related tasks and spending real time manually coordinating handoffs between them, checking statuses, and remembering who’s responsible for what, Paperclip’s task tracking and review workflow likely saves more than the coordination overhead costs. The checkout mechanism that prevents two agents from claiming the same task, and the ability to enforce a review stage before a task can close, are the kind of guardrails that matter once a team gets past one or two agents.
If you’re mostly firing off short requests to a single coding agent, setting up an organization, hierarchy, and review pipeline is probably unnecessary overhead, both in setup time and in the extra model usage that layered review and coordination introduces. The sensible test is whether a task actually needs coordination between multiple agents. If it doesn’t, the simplest setup is also the cheapest one.
It’s also worth being skeptical of the “autonomous company” framing some agent platforms lean into. Giving an agent a CEO role and an org chart doesn’t make it good at deciding what’s worth building. You still need a clear goal, specific instructions, and someone checking the actual output, which is exactly the oversight a budget cap and a review stage are designed to support, not replace.
Frequently Asked Questions
Is Paperclip completely free to use?
The Paperclip software itself is free and open-source under the MIT license, and self-hosting it costs nothing beyond your own infrastructure. The agents it coordinates (Claude Code, Codex, Gemini CLI, and others) run on your existing subscriptions or API keys, which are billed separately by those providers.
Can I set a hard spending limit so costs don’t run away?
Yes. Paperclip supports budgets at the company, agent, or project level, along with warning thresholds and configurable hard stops. However, enforcement is based on recorded usage reporting rather than real-time metering, so work already underway when a limit is hit can push spending slightly past the configured cap.
Does adding more agents automatically cost more?
Other agents start typing. Remy starts asking.
Scoping, trade-offs, edge cases — the real work. Before a line of code.
Generally yes, since each additional agent that touches a task, like a reviewer sending work back to an implementer, adds its own model usage. Paperclip’s own coordination layer doesn’t cost anything extra, but more agents in a workflow typically means more total model calls.
Do I need a separate API key to connect Claude Code or Codex?
Not necessarily. Depending on the adapter, Paperclip supports logging in with an existing subscription rather than requiring a standalone API key. Which method is used depends on the specific adapter and how it’s configured, so it’s worth checking the adapter documentation for the tool you plan to connect.
Should I start with a large team of agents or a small one?
A small setup is the more practical starting point. A coordinator plus one or two agents with clearly defined jobs is enough to test whether the coordination overhead is worth it, and running one small task first gives you a real cost figure to base future budgets on, rather than guessing.