Anyone running several AI agents at once — several Claude Code terminals, say, or a mix of Codex, Cursor, and custom scripts — knows the problem: at some point you lose track of which agent is working on what, how much budget has already been spent, and who has which permissions. That is exactly the gap Paperclip is built to close: an open-source orchestration platform for teams of AI agents.
The project’s own tagline sums up the concept well: “If OpenClaw is an employee, Paperclip is the company.” While a single agent tool gets one task done, Paperclip provides the structure a team of such workers needs — org charts, budgets, governance, and goal alignment.
Table of Contents
What is Paperclip?
Paperclip (github.com/paperclipai/paperclip) is, technically, a Node.js server with a React UI that orchestrates a team of AI agents toward a business goal. Users first define a goal — the repository’s own example is “Build the #1 AI note-taking app to $1M MRR.” Agents are then “hired” into different roles: CEO, CTO, engineers, designers, marketers — any bot, any provider. From there, users review the proposed strategy, set budgets, and monitor ongoing work from a dashboard.
The project is released under the MIT license, runs self-hosted, and requires no Paperclip account. According to its own description, Paperclip is explicitly not a single-agent tool and not a code review tool — it is built to coordinate teams, or organizations, of agents, not for occasional use of a single assistant.
Core features
The repository frames the platform around four pillars: an agentic task manager (tasks, approvals, review gates), an org chart for mixed human-and-agent teams (roles, delegation, governance), a training layer for agent skills, and an underlying “Agentic OS” infrastructure (runtime, sandboxing, MCP server integrations, cost controls).
In practice, that means:
- Org charts: Agents get roles, titles, and reporting lines — the same as human employees. One agent can report to another, delegate tasks, or escalate them.
- Cost tracking and budgets: Every agent is assigned a monthly token budget. At 100% budget utilization the agent auto-pauses and new tasks are blocked — a safeguard against runaway API costs from faulty loops or sprawling sessions going unnoticed.
- Heartbeats: Agents wake on a schedule, check the state of their work, and act accordingly. Delegation flows both up and down the org chart. This is what makes recurring automated tasks — customer support, social media posts, regular reports — schedulable without anyone having to trigger them manually.
- Governance: Who is allowed to change what is explicitly defined. Hiring new agents, for example, is gated by Board approval by default. Secrets are scoped per agent, and company boundaries strictly separate data between different organizations (multi-organization support with complete data isolation).
- Ticketing: Every conversation and every decision is traceably logged — including full tool-call tracing and an immutable audit log.
Installation and getting started
The fastest way in is a single command:
npx paperclipai onboard --yesAlternatively, Paperclip can be set up manually: clone the repository, install dependencies with pnpm install, then start it with pnpm dev. The local API server then runs on localhost:3100 by default, with an automatically configured PostgreSQL database. Requirements are Node.js 20 or later (24.11+ recommended) and pnpm 9.15 or later. Because Paperclip is self-hosted and needs no cloud account, data, secrets, and infrastructure stay entirely under the user’s own control.
Three practical use cases
The following three scenarios are deliberately framed as plausible, illustrative examples, not documented customer case studies — they are meant to show what Paperclip’s individual features are useful for in practice.
1. Solo developer: coordinating multiple coding agents on a side project
An indie hacker works on a side project in the evenings and has several coding agents running in parallel — Claude Code for backend logic, Codex for test cases, and Cursor for UI tweaks, say. Without orchestration, that means several open terminal tabs, no central view of which agent is working on what, and no warning if one of the sessions is quietly burning through a large amount of tokens.
In Paperclip, this setup can be modeled as a single, small organization: each coding agent gets a role (e.g. “Backend Engineer”, “QA”, “Frontend”) and a fixed monthly budget. Tasks are tracked as tickets, so context survives even after a machine reboot — according to the project, sessions persist across reboots instead of being lost every restart. The developer keeps an overview via the dashboard of which agent is working on which ticket at any time, and automatic budget throttling prevents a faulty loop from quietly running up API costs overnight. For a side project of modest scope, this replaces the usual patchwork of notes, open tabs, and manual tracking.
2. Recurring automation: customer support, social media, and reports via heartbeats
A small company wants to automate three recurring tasks that were previously kicked off manually: a daily pass over incoming support requests with draft replies, scheduled social media posts, and a weekly status report to management. Each of these tasks follows a fixed rhythm, but still requires someone to remember to start it — and, in doubt, to check whether the result is usable.
This is exactly what Paperclip’s heartbeats are designed for: agents wake up on a fixed schedule, check the current state of their task, and act accordingly, without anyone having to trigger the process manually. A “Support” agent could review new tickets each morning and prepare draft replies, a “Social Media” agent could publish scheduled posts at fixed times, and a “Reporting” agent could compile a weekly summary and route it to the responsible person. Because every one of these routines is traceably logged through the ticket system, it’s possible afterward to see exactly which decision was made and when — an important difference from a plain cron-job automation with no audit trail. Governance rules can additionally ensure that, for instance, an actual publish only happens after human approval, if that’s desired.
3. Larger team setup: multiple specialized agent roles building a feature
A growing software team wants to build a new feature in a division-of-labor way — not through a single agent, but through a team of specialized roles. In Paperclip, that might look like this: a “CTO” agent receives the top-level goal (“Ship collaboration features”) and plans the technical architecture. Several “Engineer” agents then take on individual sub-tasks in parallel — implementing real-time sync, for example — while another agent acts as a code review / QA layer, checking the results before they count as done.
The goal-alignment feature matters here: every single task carries the full goal ancestry back to the company mission, so each agent knows not just what to do but also why. Governance rules define who on the team has which permissions — for instance, whether an Engineer agent can independently hire new agents (gated by Board approval by default) or whether certain configuration changes require sign-off. Because configuration changes are, according to the project, revisioned and can be rolled back when needed, a faulty decision by one agent can be corrected after the fact without losing the rest of the work. For a team assigning several agents to different parts of a feature simultaneously, this setup replaces the manual coordination overhead that would otherwise be needed between several independently running tools.
Who is Paperclip for — and who isn’t it for?
According to its own description, Paperclip is aimed at anyone coordinating several agents at once, building autonomous organizations of AI agents, or regularly losing track of many parallel sessions. Anyone who wants to keep costs across multiple agents in check and enforce budgets is also part of the target audience.
For occasional, single-agent use of one AI assistant, on the other hand, the platform is explicitly not intended — anyone who only spins up a coding agent for the occasional task doesn’t need an org chart, budget management, or heartbeat scheduling. Paperclip solves the coordination problem that only emerges once multiple agents are running simultaneously and continuously.
Compatibility with common agents and tools
Paperclip is deliberately built to be agent-provider-agnostic. According to the project, it works with OpenClaw, Claude Code, Codex, and Cursor, as well as plain bash and HTTP adapters. The underlying principle: “If it can receive a heartbeat, it’s hired” — any agent that can be triggered on a schedule can, in principle, be plugged into a Paperclip org chart.
Conclusion
Paperclip addresses a problem that grows more relevant as the number of simultaneously running AI agents increases: coordination, cost control, and traceability across multiple agents. Rather than another single-agent tool, this open-source project provides the organizational layer above them — org charts, budgets, heartbeats, and governance. For developers and teams already running several agents in parallel, or looking to reliably schedule recurring automated tasks, the MIT-licensed, self-hostable project on GitHub is worth a look. If you are generally looking for free developer tools, check out our collection 10 Free Open Source GitHub Tools; for a closer look at individual coding agents themselves, see our AI Coding Agents Compared.
Frequently Asked Questions about Paperclip
What is Paperclip AI?
Paperclip is an open-source orchestration platform that coordinates a team of AI agents toward a business goal. Technically it consists of a Node.js server and a React UI that provide org charts, budgets, heartbeats, and governance for multiple agents at once.
Is Paperclip free to use?
Yes. Paperclip is released under the MIT license, runs self-hosted, and requires no Paperclip account. You only pay for your own infrastructure (e.g. a PostgreSQL database, which is configured automatically during setup) and the agent APIs you use.
How do you install Paperclip?
The fastest way is the command npx paperclipai onboard –yes. Alternatively, the project can be set up manually via git clone, pnpm install, and pnpm dev. Requirements are Node.js 20 or later (24.11+ recommended) and pnpm 9.15 or later.
Which AI agents does Paperclip work with?
Paperclip is deliberately agent-provider-agnostic and, according to the project, works with OpenClaw, Claude Code, Codex, and Cursor, as well as plain bash and HTTP adapters. The principle: any agent that can receive a heartbeat can be plugged in.
Who is Paperclip not a good fit for?
According to its own product description, Paperclip is not built for occasional, single-agent use of one AI assistant, and it is not a code review tool. It is specifically designed for coordinating teams, or organizations, of multiple agents running at the same time.
