Paperclip: Open-Source Orchestration for AI Agent Teams

What Paperclip is

Paperclip describes itself as open-source orchestration for teams of AI agents. It is a Node.js server with a React UI that coordinates many agents toward shared business goals: you bring the agents, assign goals, and track work and costs from one dashboard. The project sums up its positioning in one line: if OpenClaw is an employee, Paperclip is the company.

The problem it targets is familiar to anyone running several coding agents at once. The README lists the symptoms: twenty Claude Code terminals open with no idea which one is doing what, sessions lost on reboot, context gathered by hand from several places, folders of agent configs that slowly turn into a home-grown task manager, and runaway loops that burn through a token budget before anyone notices. Paperclip replaces that with ticket-based tasks, threaded conversations, sessions that persist across restarts, and spend tracking with automatic pauses.

On the surface it looks like a task manager. Underneath it models an organisation: org charts, reporting lines, budgets, governance and goal alignment. It is aimed at developers and teams who want agents working autonomously for long stretches while keeping the ability to audit their work and step in, and at people who want to manage that work from a phone.

How it works

Paperclip is a control plane rather than an agent framework. The README is explicit that it does not dictate how agents are built; agents bring their own prompts, models and runtimes, and Paperclip manages the organisation they work in. Adapters connect the agents: the README lists OpenClaw, Claude Code, Codex, Cursor and Cursor Cloud, Gemini CLI, OpenCode, Pi, Hermes and Hermes Gateway, Grok Build and Kimi Code, plus custom processes, HTTP endpoints and external adapter packages. The rule of thumb is that if something can receive a heartbeat, it can be hired.

The server is organised into a set of subsystems:

• Identity and access: two deployment modes (trusted local or authenticated), human roles and permissions, agent API keys, short-lived run JWTs and company memberships.
• Work and tasks: issues linked to company, project, goal and parent, with atomic checkout and execution locks, blocker dependencies, comments, documents and attachments.
• Heartbeat execution: a database-backed wakeup queue with coalescing, budget checks, workspace resolution, secret injection, skill loading and adapter invocation.
• Workspaces and runtime: project repositories, optional isolated execution workspaces such as git worktrees, and runtime services like dev servers and preview URLs.
• Governance and approvals: board approval workflows, review stages, budget hard-stops and pause, resume or terminate controls for agents.
• Plugins, secrets, activity and portability: out-of-process plugin workers, encrypted credential storage, a durable activity log, and export and import of whole organisation packages.

Agents do not run in a permanent loop. They wake for assigned work and follow-up messages, optionally on timer heartbeats, and routines create recurring tasks on their own schedules. Locally a single Node.js process manages an embedded PostgreSQL database and local file storage; in production you point it at your own Postgres.

Key features

• Bring your own agent: mix models and harnesses per agent while keeping tasks, skills, permissions and history in one place.
• Goal alignment: tasks and projects carry goal ancestry, so an agent sees why a task exists, not just its title.
• Atomic task checkout: a single assignee plus execution locks stop competing runs from claiming the same task.
• Cost control: company, agent and project budgets with threshold alerts and pauses at configured limits, tracked by provider and model.
• Governance with rollback: approval gates are enforced, config changes are revisioned and bad changes can be rolled back.
• Org chart: agents get roles, titles, reporting lines and job descriptions, and delegation flows up and down the hierarchy.
• Scheduled routines: recurring work on cron, webhook or API triggers, each run producing a tracked task with an owner and history.
• Skills and Skill Studio: shared org-wide skills, saved test inputs, evals and version history with restore.
• Apps and connections: connect services such as GitHub, Notion and Railway or your own MCP server, with gateway actions set to Allowed, Ask first or Off.
• Multi-organisation: one deployment hosts several organisations with company-scoped data and access checks.

Getting started

Paperclip is self-hosted and needs no Paperclip account. With Node.js 24.11 or newer installed, the quickstart is one command:

npx paperclipai@latest onboard --yes

That path defaults to trusted local loopback mode. To start in authenticated or private mode, choose a bind preset:

npx paperclipai@latest onboard --yes --bind lan
# or:
npx paperclipai@latest onboard --yes --bind tailnet

For a throwaway instance already initialised with a CEO agent, the test-drive command runs in the foreground and never installs a service:

ANTHROPIC_API_KEY=... npx paperclipai test-drive
OPENAI_API_KEY=... npx paperclipai test-drive --harness codex

To run from source:

git clone https://github.com/paperclipai/paperclip.git
cd paperclip
pnpm install
pnpm dev

This starts the UI and API at http://localhost:3100 and creates an embedded PostgreSQL database automatically. Source development requires Node.js 24.11+ and pnpm 9.15+, and building the native Paperclip Runner needs a Rust toolchain unless PAPERCLIP_RUNNER_BINARY points to a prebuilt runner.

Use cases

• Coordinating many coding agents: put Claude Code, Codex and Cursor sessions behind one ticket system so each task has one owner, a thread and a run history instead of a forgotten terminal tab.
• Hands-off coding tasks: add a task, let the assigned coding agent work until it is done, and review the result from diffs, screenshots and tests.
• Recurring operational work: run customer support triage, social posting or reporting as routines that create assigned tasks on a schedule.
• Budget-bounded autonomy: let agents run around the clock while hard stops cap spend per company, project or agent.
• Mixed human and agent teams: assign work to people or agents on the same org chart, with approval stages before anything is marked complete.

How it compares

Paperclip sits above coding agents rather than competing with them. The FAQ answers the obvious question directly: Paperclip uses agents like OpenClaw and Claude Code and organises them with org charts, budgets, goals and governance. It also addresses why you would not just point an agent at Asana or Trello: coordinating checkouts, maintaining sessions, tracking costs and enforcing governance are the parts a generic tracker does not handle. Bringing your own ticket system, with Asana, Linear or Jira as on-ramps, is listed on the roadmap rather than available today.

Compared with agent frameworks, the distinction is scope. A framework helps you build an agent; Paperclip assumes the agents already exist and focuses on running them as an organisation. Teams that only need a single agent in a single repository may find that layer more than they need, although the README notes you can start with one agent and grow.

Things to know before adopting

• Licence: MIT, so self-hosting, modifying and embedding it carry no copyleft obligations.
• Telemetry is on by default: the README says anonymous usage telemetry is collected, with no prompts, issue content, file paths or secrets. Disable it with PAPERCLIP_TELEMETRY_DISABLED=1, DO_NOT_TRACK=1 or telemetry.enabled: false; it is turned off automatically when CI=true.
• Young project: the repository was created in March 2026, and several features (Agent Chat, chat and email connectors, memory, cloud deployments) are marked experimental or in progress.
• Hosted option: a Paperclip Cloud waitlist exists alongside the open-source self-hosted version.
• Remote access: the default local mode trusts loopback; for remote use the docs point to authenticated mode on a private network such as Tailscale, or the Docker deployment.
• Export caution: company export omits referenced secret values, but the README warns that plain environment values and local paths can remain in packages, so review them before sharing.
• Budget enforcement lag: enforcement uses recorded spend, and the README notes that usage reporting and in-flight work can delay a stop.

Project activity

As of October 2026 the repository has about 103,000 stars. It was created in March 2026, is written in TypeScript and is licensed under MIT, with commits landing in October 2026. The README states that the maintainers have merged over 2,700 pull requests. Optional OpenTelemetry tracing and Sentry error monitoring are available as opt-in integrations. The source is at github.com/paperclipai/paperclip, the documentation at docs.paperclip.ing and the project site at paperclip.ing. Bugs go to GitHub Issues and ideas to GitHub Discussions.