Paperclip

Platform · Last verified 2026-09-30

TL;DR

Paperclip is a self-hosted Node.js server and React app from Paperclip Labs that models a team of AI agents as a company, with an org chart, goals, tickets, budgets and approval gates. It does not build agents; it runs existing ones such as Claude Code, Codex, OpenCode, Hermes and OpenClaw. It suits people supervising many agents.

Key facts

Paperclip key facts. Data as of 2026-09-30.
Type	Platform
Languages / SDKs	TypeScript
License	MIT
Pricing model	Unknown
Orchestration pattern	Supervisor
GitHub stars	95,008 (as of 2026-09-30)
GitHub forks	16,129
Last push	2026-09-30
Latest release	v2026.916.1
Repository	paperclipai/paperclip
Website	paperclip.ing
Documentation	docs.paperclip.ing
Last verified	2026-09-30

Key features

Agents sit in an org chart with roles and reporting lines; a CEO agent turns a company goal into tasks and assigns them to reports, who may delegate further. (source)
Adapters launch or call the runtime that does the work: Claude Code, Codex, Gemini CLI, Cursor, OpenCode, Pi, Hermes, Grok, Kimi Code, an OpenClaw gateway, plus generic process and HTTP adapters. (source)
An agent wakes on a timer heartbeat (off by default), on task assignment or comment, on demand, or when a cron- or webhook-triggered routine creates an issue for it. (source)
Approvals gate consequential actions: hire requests, the CEO's strategy and budget overrides wait for a board decision (approve, reject or request revision). (source)
Execution policies add review and approval stages to an issue, so closing it routes the work to a reviewer or approver instead of relying on the agent to ask. (source)
Token and cost tracking per agent with monthly budgets; an agent that reaches its limit is paused. (source)
Opt-in isolated execution workspaces give a task its own git worktree and branch so several agents can work on one project at the same time. (source)
An experimental tool gateway brokers agent calls to connected MCP servers and REST tools under allow, block, approval and rate-limit policies, and can expose a named MCP gateway to outside clients. (source)

Architecture and orchestration pattern

Pattern: Supervisor

Paperclip is a single Node.js server with a React UI. Locally it starts an embedded PostgreSQL database and local file storage; for production the README says to point it at your own Postgres. One deployment can hold several companies with separate data. Agents are records in the database with a role, manager, budget and adapter configuration; the runtime that does the work stays outside Paperclip.

Coordination is hierarchical. A company goal goes to a CEO agent, which proposes a strategy, waits for board approval, then creates issues and assigns them down the reporting chain. Agents do not talk to each other directly: work moves through issues, comments, assignments and blocker dependencies. Task checkout is atomic so two agents do not take the same issue, and each run records logs, cost events and session state, which the README says lets an agent resume the same context across heartbeats.

Memory and knowledge are not a product feature yet: the README roadmap lists Memory / Knowledge as not done. Persistent context comes from the issue history and from each runtime's own session resume (for example Claude Code or Codex sessions).

Human in the loop

The board (the human user or users) approves hire requests and the CEO's strategy before agents proceed, and can answer with Reject or Request Revision plus a comment that the agent reads on its next run. Execution policies can force a review stage and an approval stage on individual issues. Budget hard stops pause an agent and raise an approval for board action. The README says any agent can be paused, resumed or terminated at any time, and every mutating action is written to an activity log.

Harnesses it can drive

Claude Code (evidence)
Codex (evidence)
OpenCode (evidence)
OpenClaw (evidence)
Hermes (evidence)

Protocols

MCP, A2A and AG-UI support for Paperclip. See the full matrix.
Protocol	Support	Note
MCP	Partial evidence checked 2026-09-30	The tool gateway brokers calls to connected MCP servers and can expose a named MCP gateway to outside MCP clients, but the page labels the surface Experimental and off by default; a separate how-to says MCP wiring otherwise lives in the agent runtime (Claude Code, Hermes), not in Paperclip.
A2A	Unknown checked 2026-09-30	Not mentioned in the README or the docs pages read; GitHub code search for a2a returned only an 'a2a' entry in the TOOL_APPLICATION_TYPES constant and planning docs, with no documentation of what it does, and agent2agent returned nothing.
AG-UI	Unknown checked 2026-09-30	Not mentioned in the README or docs pages read; GitHub code search for ag-ui returned one internal chat-adapter research note only; Paperclip is not in the AG-UI README integration list.

Best for

Supervising many CLI agents (Claude Code, Codex, OpenCode, Hermes, OpenClaw) from one ticket board with budgets, instead of many separate terminals.
Running several coding agents against one repository, each in its own git worktree, using the experimental isolated workspaces. (shortlist)
Recurring agent work on a schedule or webhook, such as daily reports, through routines that create tracked issues.
Self-hosting a local control plane with embedded Postgres and no vendor account. (shortlist)
Work that needs a human sign-off step (review and approval stages) before an agent's task counts as done.

Not for

A single agent or a single project; the README says one agent probably does not need Paperclip.
Building agent logic or drag-and-drop pipelines; the README states it is not an agent framework and not a workflow builder.
Teams that need built-in agent memory or a knowledge base today; the roadmap lists it as not done.

Quickstart

npx paperclipai onboard --yes

Install not yet verified by this site. What this means

# Node.js 24.11+ required; run as a normal user, not root
npx paperclipai onboard --yes   # creates ~/.paperclip/, starts the server at http://localhost:3100

# restart the server after a reboot
npx paperclipai run

# throwaway instance with a CEO agent already hired (uses your own key)
ANTHROPIC_API_KEY=<your-key> npx paperclipai test-drive

# optional: keep it running as a background service
npx paperclipai install
paperclipai service install

Common pitfalls

Needs Node.js 24.11 or newer (pnpm 9.15+ for the git-clone path).
Do not run onboarding with sudo or as root: the embedded PostgreSQL refuses to start as an administrative user.
On Apple Silicon Macs, embedded Postgres can fail to start until versioned libzstd and liblz4 symlinks are created; the install page shows the commands.
If npx returns E404 for paperclipai because a private registry is set in ~/.npmrc, add --registry https://registry.npmjs.org.
Agents call model providers that bill you directly; the docs warn an active team can cost $20 to $100+ per month. Timer heartbeats are off by default.
Anonymous telemetry is on by default; disable with PAPERCLIP_TELEMETRY_DISABLED=1 or DO_NOT_TRACK=1.

Official quickstart

Pros

Agents wake on assignment, comment, on-demand or routine triggers by default; timer heartbeats are opt-in, which limits idle token spend. (source)
Review and approval stages are enforced by the runtime when an issue is closed, not left to the agent to remember. (source)
One board covers agents from several vendors' CLIs and gateways through built-in adapters. (source)
Per-agent monthly budgets pause agents at the limit, and costs are recorded per call. (source)
MIT-licensed and self-hostable with an embedded database, with no Paperclip account needed for the local install. (source)

Cons

Model calls are billed by the provider and the docs warn an active team can spend $20 to $100+ per month. (source)
Isolated workspaces, the tool gateway and other features are experimental, with no compatibility guarantees stated in the docs. (source)
The README roadmap lists Memory / Knowledge, Work Queues and Self-Organization as not yet done. (source)
An open issue reports that budget governance does nothing under subscription billing because billed cost is 0. (source)
Anonymous usage telemetry is enabled by default and must be switched off by env var or config. (source)

Alternatives

FAQ

Is Paperclip an agent framework?

No. The README says it does not tell you how to build agents; it runs existing agents (Claude Code, Codex, OpenCode, Hermes, OpenClaw and others through adapters) inside an org chart with tickets, budgets and approvals.

Does Paperclip support MCP?

Partly. The tool gateway can broker calls to MCP servers and serve a named MCP gateway, but the docs mark it Experimental and off by default. For Claude Code or Hermes agents, MCP servers are otherwise configured in the runtime itself.

Is Paperclip free?

The code is MIT-licensed and can be self-hosted without an account. The docs and site also mention a managed Paperclip Cloud with a waitlist, but no pricing page was found, so the pricing model is recorded as unknown. You still pay your model providers for agent runs.

Which languages is it written in?

The repository is TypeScript (a Node.js server and React UI); agents themselves can be any runtime reachable through an adapter.

Sources

Unknown fields: pricing_model: MIT code, but docs mention a managed Paperclip Cloud and paperclip.ing shows a waitlist; no official pricing page found (paperclip.ing/pricing returns 404, docs have none). protocols.a2a and protocols.agui: searched README, docs pages, GitHub code search; no documented support (only an 'a2a' constant in TOOL_APPLICATION_TYPES with no docs).

Something wrong or out of date, or do you maintain Paperclip and want this page removed? Report a correction or request removal.