Who paperclip is for#
Founders building autonomous AI companies
Paperclip's org chart model is designed for this: define a company goal, hire CEO, CTO, engineer, and marketing agents, approve the CEO's strategy, and monitor from the dashboard. The multi-company feature means one deployment can run multiple portfolio companies in isolation.
Skip if:
You only want to run one or two agents on a single project. Paperclip's governance and org overhead is not worth it for that scope; a simpler task runner or direct CLI invocation is faster.
Developers managing many parallel coding agents
The ticket system tracks every agent conversation, decision, and tool call. Persistent task context means agents resume where they left off after a reboot, and budget controls prevent runaway spend. Works directly with Claude Code, Codex, and Cursor under one org chart.
Skip if:
You are running a single coding agent and primarily care about code output quality. Paperclip adds coordination infrastructure, not coding capability; if your bottleneck is the agent's output rather than management overhead, Paperclip does not address that.
Teams needing cost control on AI agent spend
Monthly budgets are enforced per agent and per project. When an agent hits its budget limit, it stops. Cost events are tracked by provider and model. You get warning thresholds before the hard stop, so you can adjust budgets before work is interrupted.
Skip if:
Your agent spend is small and predictable enough to monitor manually. Paperclip's budget system adds value at scale; for light usage with one or two low-cost agents, a monthly API dashboard is sufficient.
IT teams running recurring agent routines
Heartbeat scheduling handles recurring tasks with cron, webhook, and API triggers. Each routine run creates a tracked issue, assigns it to the relevant agent, and produces a full audit trail. No manual kick-offs, no lost runs.
Skip if:
Your recurring tasks are simple enough for a cron job calling a script directly. Paperclip's routing, audit logging, and governance add value when coordinating multiple agents; for a single automated script, the overhead is not warranted.
The problem it solves#
Running multiple AI agents without centralized management is messy. You open twenty coding agent tabs, lose track of which agent is working on what, and restart context from scratch every time a session drops. There is no shared view of costs, no way to enforce budgets, and no audit trail of what each agent decided and why. Recurring tasks require manual kick-offs. Agents work in isolation without shared goals, so they duplicate work or pull in conflicting directions.
The problem worsens at scale. Token spend goes unmonitored until a bill arrives. There is no governance layer: any agent can run any command without approval gates. Moving between providers or agent runtimes means rebuilding your orchestration layer from scratch each time. Most teams end up with folders of disconnected agent configs and no coherent model for who is working on what.
How it solves it#
Org chart for AI agents
Gives each agent a role, title, reporting line, and job description inside a visual org chart. Delegation flows up and down the hierarchy: a CEO agent can spin up engineers, designers, or marketing agents and assign work to them. Roles scope what each agent can do and what secrets it can access.
Goal-aligned task system
Every task carries the full goal ancestry from the company mission down to the individual ticket, so agents always know what they are doing and why. Tasks are ticket-based, with threaded conversations, attachments, comments, and work products. Atomic task checkout prevents double-work across agents.
Per-agent budget enforcement
Monthly token and cost budgets are set per agent. When an agent hits its limit, it stops automatically. Cost events are tracked by company, agent, project, goal, and model provider, so you can see exactly where spending is concentrated and adjust budgets without waiting for a surprise invoice.
Heartbeat scheduling
Agents wake on a configurable schedule, check their assigned work, and act. Recurring tasks such as customer support responses, social posts, or nightly reports run without manual kick-offs. Each heartbeat run produces structured logs, cost events, and an audit trail. Orphaned runs are recovered automatically.
Bring-your-own-agent runtime
Works with any agent that can receive a heartbeat: Claude Code, Codex, Cursor, Gemini, Bash scripts, and HTTP bots. No model or provider lock-in. Adapter examples cover CLI agents, HTTP/webhook bots, and plugin-based extensions. One org chart, many agent types.
Governance and approval gates
Board approval workflows let you review and approve an agent's strategy before it runs. You can pause, resume, or terminate any agent at any time. Config changes are revisioned, bad changes can be rolled back, and every mutating action is recorded in an immutable audit log.
Strengths and trade-offs#
Strengths
- Provider-agnostic by designPaperclip does not tie you to a specific model or agent vendor. The same org chart runs Claude Code, Codex, Cursor, Gemini, Bash agents, and HTTP bots simultaneously. Switching providers or adding new agent types does not require rebuilding the orchestration layer.
- Persistent task state across rebootsTasks and agent context persist across heartbeats and system reboots. Agents resume the same task context instead of restarting from scratch, solving the practical problem of losing work context when running many agent sessions simultaneously.
- MIT license with full source accessThe self-hosted tier is MIT licensed. You can run it commercially, fork it, modify it, and extend it without licensing fees or restrictions. Proprietary agent management services cannot offer the same guarantee: the source is closed and the terms can change.
- True multi-company isolation on one serverA single Paperclip deployment can run multiple companies with complete data isolation. Each company has its own agents, budgets, secrets, and audit trails. One control plane manages the portfolio without data leaking between entities.
Trade-offs
- -Not useful for single-agent workflowsIf you have one agent, you probably do not need Paperclip. The overhead of org charts, governance, and budget tracking adds friction not justified for simple single-agent tasks. Users running fewer than three or four agents will likely find a lighter orchestration script more practical.
- -5,080 open issues reflects rapid early growthThe repository had 5,080 open issues as of August 2026, high relative to its five-month age. This reflects rapid community growth, but users should expect rough edges in less common adapter configurations and plugin integrations as the project matures.
- -Self-hosting requires running a Node.js serverPaperclip is a full Node.js server plus React UI. There is no managed cloud tier: you run the server. The install script handles Node.js bootstrapping on Linux and macOS, but users on other platforms or restricted environments will need to handle dependencies manually.
paperclip vs alternatives#
Paperclip vs DIY Multi-Agent Setup
Without a dedicated orchestration layer, most developers manage many AI agents by keeping multiple terminal sessions open, one per agent. Context is lost on reboot, there is no shared task state between agents, and cost monitoring requires checking each provider's dashboard separately.
Paperclip replaces that approach with a unified control plane: persistent ticket-based tasks, per-agent budgets with hard stops, org-chart-based coordination, and an immutable audit log of every decision. The tradeoff is infrastructure: you run a Node.js server, not a lightweight CLI.
The DIY approach still works for developers running one or two agents on short-lived experiments where the overhead of a ticketing system and org chart is not justified.
Paperclip vs Commercial Agent Management Platforms
Proprietary agent management platforms that run as managed cloud services offer faster onboarding (no server to run) and often tighter integration with specific model providers. They are a reasonable choice for teams with no ops capacity or strong preferences for a specific vendor ecosystem.
Paperclip trades that convenience for ownership. The MIT license means you can fork it, extend it, and run it commercially without licensing fees or vendor terms changing under you. Agent provider choice is fully open: any model, any runtime, one org chart.
Teams that need zero infrastructure overhead and do not mind vendor lock-in should evaluate commercial platforms. Teams that need data sovereignty, multi-company isolation on one server, or the ability to modify the orchestration layer should use Paperclip.
Install and self-host#
Paperclip installs via a shell script that sets up Node.js, the CLI, and optionally a background service on Linux or macOS.
```bash
curl -fsSL https://paperclip.ing/install.sh | bash
```What it's built on#
- Languages
- JavaScriptTypeScript
- Frameworks
- ExpressReact
- Infrastructure
- AWS
- Tooling
- esbuild
FAQ#
Is Paperclip free to use?
Yes. The self-hosted version is MIT licensed and free to run on your own infrastructure with no licensing fees. There is no managed cloud tier and no Paperclip account required. You pay for your own server and the model API keys for whichever agents you run.
Which AI agents does Paperclip support?
Any agent that can receive a heartbeat. The project lists Claude Code, Codex, Cursor, Gemini, Bash scripts, and HTTP/webhook bots as supported adapter types. Paperclip does not supply or run agents itself; it organizes and schedules agents you bring from their respective providers.
How does Paperclip prevent runaway AI costs?
Monthly budgets are set per agent and per project. When an agent hits its budget limit, Paperclip stops it automatically and cancels any queued work. Cost events are tracked by provider, model, goal, and issue, so you can see exactly where spending is concentrated before it becomes a problem.
Can Paperclip run multiple companies on one deployment?
Yes. The multi-company feature gives each company complete data isolation: separate agents, budgets, secrets, projects, and audit trails on a single server. One control plane manages the portfolio without any data leaking between companies.
How is Paperclip different from a workflow automation tool?
Paperclip does not use drag-and-drop pipelines or node graphs. It models an organization: agents have roles, report to managers, and work toward company goals. A workflow automation tool connects discrete triggers and actions; Paperclip manages a team of autonomous agents that decide how to accomplish goals on their own.
Similar open-source tools#
LifeOS
AI-powered life operating system for goal achievement
AFFiNE
Local-first workspace combining docs, whiteboards, and notes
Comp AI CRM
Open source agentic CRM with a durable research agent
agency-agents
Expert AI agent personalities for every workflow
FluidVoice
Voice-to-text for macOS with on-device AI and zero cloud dependency
hiring-agent
AI-powered resume evaluation and scoring tool