The moment a team goes from one AI coding agent to five or ten running at once, a specific, recognizable mess shows up: a dozen terminal tabs nobody can label, agent configs scattered across folders, no record of who approved what, and a token bill that spikes overnight because one agent got stuck in a loop. Paperclip is built specifically for that mess — not another agent framework, but a control plane that sits on top of whatever agents you're already running and gives them an org chart, a budget, and an approval process.
The Core Idea: Manage Agents Like Employees, Not Scripts
Paperclip's framing is explicit and a little unusual: agents get roles, titles, reporting lines, and budgets, the same as a human hire would. Tasks aren't fire-and-forget prompts — they're tickets that carry the full chain of why a task exists, tracing back through a project to a company goal, so an agent picking up work three levels deep in a hierarchy still has the context for what it's actually for. Recurring work runs on heartbeats: agents wake on a schedule, check for work, act, and go back to sleep, rather than needing a human to remember to kick off the weekly report or the daily support triage.
The project organizes itself around four things it argues have to work for a group of agents to actually be productive together:
| Pillar | Covers |
|---|---|
| Agentic Task Manager | Tickets, approvals and review gates, auditable routines, verification from diffs/screenshots/tests |
| Org Chart for Agents | Roles, delegation, specialization, governance over who can do what, scoped secrets |
| Agent Employee Training | A skill library shared org-wide, evals, saved test runs, performance tracking |
| Agentic OS | The runtime underneath — any model, any agent, sandboxing, integrations, SSO/RBAC, cost controls |
What Actually Makes This Different From a Task Board
A handful of design decisions in the README are worth calling out specifically, because they're the parts that separate this from "Trello with an AI label" or a thin wrapper around an existing framework:
- Atomic task checkout and budget enforcement. Two agents can't grab the same ticket, and a budget hard-stop can't be raced past — both are enforced atomically, which matters once you have enough concurrent agents that races become a real, regular occurrence rather than a theoretical one.
- Persistent state across heartbeats. An agent resumes the same task context on its next wake-up rather than starting cold every time, which is the difference between a genuinely long-running worker and a stateless script that happens to run on a timer.
- Cost control as a first-class feature, not a dashboard. Budgets are scoped per company, agent, project, and even individual issue, with hard stops that pause an agent and cancel its queued work automatically when it runs out — a direct answer to the specific, common failure mode of a runaway agent loop burning through a token budget overnight.
- Bring-your-own-agent, not a walled garden. Claude Code, Codex, CLI agents, and HTTP/webhook bots all plug in through adapters — the stated bar is "if it can receive a heartbeat, it's hired." Paperclip explicitly doesn't tell you how to build an agent; it manages the organization the agents you already have work inside of.
- True multi-company isolation. Every entity in the system is scoped to a company, so one deployment can run multiple separate organizations — with genuinely separate data and audit trails — rather than one flat workspace.
What It Deliberately Doesn't Do
The README is unusually direct about scope, which is worth taking at face value: it explicitly says it's not a chatbot, not an agent framework, not a workflow builder, not a prompt manager, and not a code review tool. Its own honest self-assessment on fit is blunt too — if you're running one agent, you probably don't need this; the value shows up once you're coordinating enough agents that keeping track of them by hand has become the actual bottleneck.
That scoping matters for evaluation. Paperclip assumes you already have agents and frameworks you like — it isn't competing with Claude Code, Codex, or Cursor, it's the management layer that sits above all of them at once.
Running It
Paperclip is fully open source (MIT-licensed) and self-hosted — there's no hosted account required to run it, and the installer sets up an embedded PostgreSQL database automatically, so there's no separate database to stand up first. It ships in two access modes: a trusted local loopback mode for the fastest first run, and an authenticated mode (LAN or Tailscale-bound) for anything beyond a single machine. Given that it's explicitly built to hold agent secrets, budgets, and cross-system access, that mode choice is worth making deliberately rather than defaulting into whatever the quickstart picks — the authenticated path is the one to use for anything beyond a solo local experiment.
The actual quickstart is a shell script fetched with curl, checked against a published SHA-256 checksum, and run — it installs a managed CLI under ~/.paperclip/cli, checks for Node.js 20 or newer, and can register itself as a background service on supported Linux and macOS systems. A non-interactive path (--no-prompt --no-onboard, followed by onboard --yes) exists for scripted setups, and there's an npx-based path for trying it without installing anything permanently. By default the onboarding flow now picks trusted local loopback mode for speed; passing --bind lan or --bind tailnet explicitly switches to authenticated mode at setup time instead of after the fact. For anyone who'd rather run it from source directly, git clone, pnpm install, and pnpm dev starts the API server on localhost:3100 with the same automatic embedded-Postgres behavior — that path requires Node.js 20+ and pnpm 9.15+.
What's Actually Shipped vs. Still Coming
The project's own roadmap is a useful reality check on how much of the "org chart for agents" pitch is already built versus aspirational. Already shipped, by the roadmap's own accounting: the plugin system, OpenClaw-style agent employees, full company import/export, a Skills Manager and Skill Studio, scheduled routines, budgeting, agent review and approval workflows, multi-human-user support, cloud and sandboxed agent execution across several providers, deep planning with revisioned plans, an MCP tool gateway, and a scoped secrets manager. Still open, and worth knowing about before assuming they exist: a dedicated memory/knowledge layer, work queues, automatic organizational learning, a desktop app, bring-your-own-ticket-system support for teams that want to keep using Asana, Linear, or Jira instead of Paperclip's own tracker, and one-click Connected Apps (currently shipping gated behind an experimental settings flag). That last item — Connections v3 — is under active development in recent releases, laying groundwork for governed, scoped API access to third-party services rather than raw secret injection.
Practical Implications
- If you're already past the "folder of scripts" stage, running several agents against real, ongoing work, this addresses a genuine operational gap — coordination, budget enforcement, and audit trails are the unglamorous engineering that a growing agent fleet needs and that most teams end up half-building themselves.
- The governance model is the part worth taking most seriously before adoption. Approval gates, budget hard-stops, and scoped secrets are exactly the controls a security review would ask for anyway when agents get real system access — evaluate them as you would any system that's about to hold credentials and make autonomous decisions, not as a convenience feature.
- It's still an early, fast-moving project. It was created in 2026 and is shipping detailed, frequent releases with real migrations and a genuine multi-contributor team behind it — a sign of active development, but also a reason to expect breaking changes and rough edges more often than a mature, stable platform would have.
- The "org chart" metaphor is a real design commitment, not just marketing. If your mental model for running agents is closer to a pipeline or DAG than a company hierarchy, the fit may be less natural than for a team that's already thinking in terms of roles and delegation.
Practical Takeaway
Paperclip is a bet that the interesting problem in multi-agent systems has stopped being "how do I get one agent to do a task well" and started being "how do I run twenty of them without losing track of what they're doing and why" — and it's built entirely around that second problem rather than competing on the first. For a team that's already past the single-agent stage and starting to feel real coordination pain, it's worth evaluating on its own terms: try the local quickstart, look hard at the governance and budget controls specifically, and decide whether the org-chart model matches how your team actually wants to manage a growing fleet of autonomous coworkers.
Teams standing up multi-agent operations — and needing the governance, identity, and cost-control layer around them done right — can get hands-on architecture help from Woyce Technologies.
FAQ
What is Paperclip?
Paperclip is an open-source, self-hosted control plane for managing teams of AI agents — giving them roles, budgets, scheduled work via heartbeats, and an approval workflow, similar to how a company manages employees, rather than functioning as an agent-building framework itself.
Is Paperclip free to use?
Yes, it's MIT-licensed and fully open source. It's self-hosted with no Paperclip account required, and an embedded database is created automatically on install.
Does Paperclip replace Claude Code, Codex, or other coding agents?
No — Paperclip is explicitly designed to sit above whatever agents you're already using. It connects to Claude Code, Codex, CLI agents, and HTTP/webhook bots through adapters rather than replacing any of them.
How does Paperclip control AI agent costs?
It tracks token and cost usage by company, agent, project, and even individual task, with scoped budget policies that include warning thresholds and hard stops — an agent that exceeds its budget is automatically paused and its queued work cancelled.
Do I need Paperclip if I only run one AI agent?
Probably not, by the project's own assessment. Its value is coordination overhead that shows up once you're running several agents at once — task tracking, delegation, and governance across a growing fleet, not the experience of running a single agent.
Is Paperclip a workflow automation tool like Zapier or n8n?
No. Paperclip explicitly avoids the drag-and-drop pipeline model — it manages an organizational structure of roles, goals, and budgets for agents rather than defining step-by-step automation workflows.
How do I install Paperclip?
The documented path is a shell script fetched with curl, verified against a published SHA-256 checksum, and run — it checks for Node.js 20+, installs a managed CLI, and can register itself as a background service. There's also a manual path (git clone plus pnpm install and pnpm dev) for running it directly from source, and an npx-based path for trying it without a permanent install.
Does Paperclip support bring-your-own issue tracker, like Linear or Jira?
Not yet — it's on the public roadmap but not shipped. Today, tasks live in Paperclip's own ticket system rather than syncing to an external tracker.
Does Paperclip collect telemetry data?
Yes, anonymous usage telemetry is enabled by default to help the team understand product usage — the project states it never collects personal information, issue content, prompts, file paths, or secrets, and private repository references are hashed with a per-install salt. It can be disabled via an environment variable, a config setting, or the DO_NOT_TRACK=1 convention, and is automatically off in CI environments.
Does Paperclip integrate with observability tooling?
Yes — it ships with opt-in OpenTelemetry auto-instrumentation for server-side traces, activated by setting the standard OTEL_EXPORTER_OTLP_ENDPOINT environment variable, with the OpenTelemetry packages themselves as optional dependencies installed only if tracing is wanted.