Paperclip: A Local Control Plane for Orchestrating Multi-Agent AI Teams
Paperclip is an open-source application that manages multiple AI agents through a corporate structure: organizational charts, ticketing systems, per-agent budgets, heartbeat scheduling, and audit logs. It launches locally with a single command and provides a web dashboard for monitoring and governance. The framework is model-agnostic and connects to agent runtimes through adapters.
The problem Paperclip addresses
Without a management layer, multiple agents working on the same codebase have no shared context, no task ownership, and no cost controls. One agent may implement a feature while another is simultaneously rewriting the architecture that feature depends on. API costs accumulate without a clear stopping condition.
Paperclip addresses this by introducing organizational structure: one agent (the CTO) breaks the overall goal into tickets and delegates them to appropriate engineers. Each agent has a monthly budget limit; when it is reached, the agent stops working.
Core components
Org chart. Agents are assigned roles with defined reporting lines. A CTO can delegate to a BackendEngineer and a FrontendEngineer. Work flows down the hierarchy.
Goal alignment and ticketing. Every company starts with a high-level mission. High-level agents break this into tickets. Every ticket traces back to the company mission.
Per-agent budgets. Each agent has a monthly spending cap. When it is hit, the agent stops. This converts autonomous operation from a financial risk into a predictable cost.
Heartbeats. Agents operate on a schedule, waking at configured intervals to check for work and then going idle. This is more efficient than continuous operation.
Governance. The human operator acts as the board. Agents can be paused, overridden, or terminated at any time from the dashboard.
Adapters. Paperclip connects to external agent runtimes and models. The example below uses Claude Code; other providers can be added.
Setup
Paperclip bundles a local server, a PostgreSQL database, and a web UI. It launches with one command:
The --yes flag accepts all prompts automatically. The setup downloads dependencies, configures the embedded database, runs environment checks, and starts the server. The dashboard opens automatically at http://127.0.0.1:3100.
Building a URL shortener with a three-agent company
The following walkthrough creates a company with a CTO and two engineers tasked with shipping a URL shortener MVP.
Creating the company
On the new company screen, set:
- Company name:
New Tools Company - Mission / goal:
Build and ship a URL shortener MVP this week.
Hiring the team
Create the CTO agent first, selecting Claude Code (local) as the adapter. The default CTO prompt instructs it to turn the company goal into a roadmap, create prioritized tickets, and delegate work down the org chart.
After the CTO is created, add two more agents from the Org tab:
BackendEngineer: owns the server-side HTTP API and persistence layerFrontendQAEngineer: owns the user-facing web UI and end-to-end QA
Setting budgets and working directories
For each agent, navigate to the Budget tab and set a monthly limit. For this project, $5.00 for the CTO and $4.00 for each engineer caps total spend at $13.
For the engineering agents, navigate to the Configuration tab and set the Working directory to a local folder where generated code will be saved.
Launching and monitoring
Click Create & Open Issue to assign the main goal as the first task to the CTO. On the next heartbeat, agents become active.
The CTO analyzes the goal, creates sub-tickets (such as "Scaffold backend server," "Design database schema," "Create API endpoints," and "Build frontend UI"), and delegates them to the engineering agents based on their defined roles. The engineering agents pick up their tickets and write code to the configured working directory.
Progress is visible in real time on the dashboard and in the Issues tab.
Output
When the agents complete their tickets, the working directory contains a full project structure: server files, HTML/CSS/JS, and a package.json. Running npm install and npm start starts the finished application.
Paperclip vs. workflow frameworks
Tools like CrewAI, LangGraph, and AutoGen define workflows: sequences of operations where the output of one agent becomes the input of the next. This model is well-suited to structured, repeatable pipelines.
Paperclip operates at a different level. It provides the organizational context in which agents or workflows operate: the hierarchy, the ticket board, the budget system, and the audit log. It does not define how a task is done; it defines who is responsible, how much they can spend, and whether they are aligned with the company goal.
Tradeoffs
Paperclip is most useful when the problem is large enough to require multiple agents with distinct responsibilities and when runaway costs are a real concern. For single-agent tasks or simple pipelines, the overhead of setting up an org chart, budgets, and working directories is unnecessary.
Output quality still depends on how well the mission and agent roles are defined. A vague mission or poorly scoped role description produces vague work, just in a more structured and observable way.
The self-hosted local model gives full data control, but running the embedded PostgreSQL instance and managing the server is infrastructure overhead that hosted tools avoid.
Final thoughts
Paperclip introduces management concepts from organizational design, such as delegation hierarchies, budget controls, and accountability through ticketing, into AI agent orchestration. The practical effect is that complex multi-agent work becomes observable and financially bounded, which are two properties that matter significantly when running agents autonomously.
Source code and documentation are at github.com/paperclip-ai/paperclip.
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License.