Skills

Paperclip: The Open-Source Orchestration Console That Runs a Bunch of AI Agents Like a Company

Suited to teams that want to pull self-supplied agents such as Codex, Claude, Cursor, and OpenClaw under one shared goal, dispatch work uniformly, watch progress, and control cost — provided you bring your own agent accounts and model quota, and run the Node.js service locally following the Quickstart.

Official source · paperclipai/paperclip

Install

https://github.com/paperclipai/paperclip#quickstart

Who it's for

Paperclip is an open-source AI agent orchestration tool, and its metaphor is blunt: agents are employees you hired, and Paperclip is the company. It is made up of a Node.js service and a React interface, and the agents are yours to bring in, so it suits technical leads or small teams that already use coding agents and want to gather those agents' tasks, permissions, and history in one place.

Three typical profiles: around twenty Claude Code terminals open at once, with no clear picture of what each one is doing; agents running on their own 7×24 while you can check progress at any time and jump in to steer them; and leads who want to set a budget cap on every agent and keep an eye on cost.

There is one hard prerequisite: you supply the agents. The repository front page states that it is "bring your own agents", and the models and execution frameworks are picked by you one by one; what the platform handles is scheduling, bookkeeping, and enforcing the budget.

It is a poor fit if you simply want a single agent to finish one task and stop — the "define a goal, hire the team, approve and run" flow is extra overhead in that case. And do not start if you have no usable agent accounts or model quota on hand, because both the agents and the models are yours to provide.

3 minutes to your first attempt

Follow one official path: the Quickstart section on the GitHub repository front page.

  • https://github.com/paperclipai/paperclip
  • https://docs.paperclip.ing/

The verified material only goes as far as "the official entry point is the Quickstart section inside the repository". For the exact commands, rely on the Quickstart and the documentation site; unverified commands are not restated here.

  1. Prepare the prerequisites: a Node.js runtime plus at least one agent of your own (Codex or Claude).
  2. Installation location: follow the Quickstart to run the service and the interface locally. The evidence gives no global install directory or package name, so do not copy the installation steps from elsewhere.
  3. Trigger a low-risk task: create a read-only analysis goal (for example "analyze the structure of a repository and list improvement items"), attach only one agent at first, review the strategy it proposes, set the budget cap to a small number, and only then click run. At this stage do not let it write files, execute commands, or make outbound calls.
  4. Confirm the side-effect boundary first: once an agent starts, it keeps running autonomously and incurs real cost. The budget cap and the read-only task are the only guardrails in this round, so set the budget low.
  5. Watch for the success signal: the goal and its task entries show up on the dashboard, you can see each agent's progress and cost accounting, and the cumulative cost stays within the budget cap.

What not to do in the first round: do not attach a dozen agents at once, and above all do not click run without a budget set.

Use cases

Case one: multiple agents advance the same goal in parallel, so progress no longer depends on anyone's memory. The repository lists "20 Claude Code terminals open at once and losing track of what each one is doing" as a directly applicable scenario. The approach is to attach different agents — OpenClaw, Codex, Claude, Cursor — under one common goal, let each pick its own model and execution framework, and keep tasks, skills, permissions, and history in one place; from then on you read the dashboard to see who is doing what and how much it has cost, without digging through terminal after terminal, and a single panel tells you who is advancing and how far along they are.

Case two: treat "set a goal, hire the team, approve and run" as an operating loop. The three steps given by the repository are: first define the goal (for example, growing an AI note-taking app to $1M MRR), then assemble a team of agents with roles such as CEO, CTO, engineer, designer, and marketing (any bot, any vendor), and finally approve and run — check the strategy, set the budget, press start, and keep monitoring from the dashboard. This is the example flow the source gives, not an inferred use; how to configure the roles and connect the agents, follow the Quickstart and the documentation site.

Limits and boundaries

  • The verified scope is limited to the repository front page: the positioning (open-source orchestration for putting AI agents to work), the technical shape, the three-step core flow, and the requirement set of "agents run autonomously 24/7, humans need to check in and can jump in at any time, cost must be monitored and the budget enforced". Installation commands, directory structure, and account-binding methods are outside the verified scope.
  • Agents keep running autonomously and incur real cost, so cost monitoring and budget enforcement are both platform capabilities and a precondition for running it.
  • Agents, models, and execution frameworks are all supplied by you; Paperclip does not host agent accounts for you.
  • For the first round pick a read-only, reversible analysis task; when it comes to writing files, executing commands, or making outbound calls, confirm the impact scope and the budget before letting it through.
  • If you only want to run one task, this flow is on the heavy side; it pays off in multi-agent, long-running, budget-constrained scenarios.
  • The repository front page says nothing about how deeply each agent is supported, the concurrency scale, or fault recovery — defer to the official documentation site.