Paperclip

Overview

Paperclip is an open-source, self-hosted control plane for teams of AI agents — often called a “company OS.” It is built by Paperclip Labs (MIT license) and published at paperclip.ing with source on github.com/paperclipai/paperclip. The product’s own framing is blunt: if an agent runtime such as OpenClaw is an employee, Paperclip is the company.

Practically, Paperclip is a Node.js API server plus a React dashboard that sits above agent runtimes. You define a company, mission, and goals; hire agents into an org chart (CEO, CTO, engineers, marketers, and so on); set monthly budgets; assign work as tickets; and supervise through governance gates (approve hires, pause agents, override strategy). Agents wake on heartbeats and event triggers, check out tasks atomically, and report costs and activity back into one place.

It is deliberately not an agent framework like CrewAI, LangGraph, or AutoGen. Those tools decide how an agent thinks (prompts, tool loops, graphs). Paperclip decides what work gets done, who owns it, what it may spend, and what requires a human board decision. Adapters treat Claude Code, Codex, Cursor, OpenClaw, bash, HTTP webhooks, and other runtimes as black boxes that can receive a heartbeat.

Setup is local-first: npx paperclipai onboard --yes (Node.js 20+, pnpm 9.15+) boots an API at http://localhost:3100 with an embedded PostgreSQL/PGlite database — no Paperclip cloud account required. Multi-company isolation lets one deployment run many separate “companies” with scoped data and audit trails. As of mid-2026 the public repo shows high community interest (tens of thousands of GitHub stars) and frequent releases (for example v2026.707.0 in July 2026).

Key features

• Org chart & roles. Agents get titles, reporting lines, permissions, and job scope. Delegation flows up and down the chart instead of living in ad-hoc terminal tabs.
• Bring-your-own-agent adapters. Built-in and plugin adapters include Claude Code, Codex, Cursor, OpenClaw gateway, process/CLI, and HTTP/webhook bots. If something can be invoked on a heartbeat, it can be hired.
• Goal-aligned work. Tasks carry goal ancestry (mission → project → task) so agents see why work exists, not only a ticket title. Skills (Markdown SKILL.md files) inject Paperclip workflows and project context at runtime.
• Heartbeats & routines. Agents wake on a schedule or when assigned / @-mentioned. Coalescing avoids duplicate concurrent runs. Cron/webhook/API routines create tracked issues for recurring work.
• Ticket system with atomic checkout. Work is issues with owners, status, comments, attachments, and execution locks so two agents do not claim the same task. Full tool-call and activity tracing support audit.
• Hard cost control. Monthly (and related) budgets per agent and company; soft warning around 80%; auto-pause and blocked new work at 100%. Cost events roll up by agent, task, project, goal, provider, and model.
• Board governance. Human operators approve hires, strategy, and budget overrides; pause, resume, reassign, or terminate agents; revisioned config with rollback. Autonomy is granted, not assumed.
• Multi-company portfolio. One instance can run many isolated companies — useful for separate ventures, sandboxes, or template orgs. Export/import with secret scrubbing supports portability.
• Plugins & MCP. Out-of-process plugins extend UI and capabilities without forking core. An MCP server wraps the REST API so MCP-capable agents can read/write Paperclip state.
• Ops surface. Optional OpenTelemetry traces, anonymous telemetry (disable with PAPERCLIP_TELEMETRY_DISABLED=1 or DO_NOT_TRACK=1), Discord community, and mobile-friendly monitoring for operators on the go.

Pricing

Paperclip itself is free and open source (MIT). There is no official Paperclip Labs subscription tier, seat license, or mandatory hosted SaaS fee as of mid-2026. You pay for infrastructure and for the LLM/agent runtimes your org chart uses.

Community write-ups and demos emphasize that the control plane fee is zero, while agent labor is not: frequent multi-agent heartbeats on raw API credits can reach hundreds to thousands of dollars per month at scale; subscription-billed CLIs can look like “$0” in Paperclip’s cost UI when providers do not return cost fields (tracked as an open product issue). Hard per-agent budgets are the primary economic control.

Limits & gotchas

• You operate the stack. Self-hosting means you own upgrades, backups, Postgres, secrets, and network exposure. Local CLI adapters often run unsandboxed on the host — treat agent permissions like production shell access.
• Not a workflow builder. There is no drag-and-drop agent graph. If you need visual pipelines, tools like n8n, Make, or Zapier fit better.
• Heartbeat latency. Default operation is scheduled/event-driven, not always real-time chat. Continuous agents (e.g. OpenClaw) can be hooked in, but the control plane’s natural cadence is ticks and tickets.
• Cost tracking gaps. Subscription-billed agents may record cost_cents = 0 when the provider omits cost metadata; token estimation workarounds exist as issues/roadmap items.
• Early product roughness. Users report bootstrap friction (e.g. CEO instruction files 404ing until fixed), agents over-literal about “company” metaphors (attempting real-world hiring workflows), and uneven docs. Roadmap items still open include deeper cloud/sandbox agents, memory/knowledge, BYO ticket systems, and first-party cloud deploy polish.
• Requires multi-agent discipline. One agent rarely needs Paperclip. Value shows up when you would otherwise juggle many Claude Code / Cursor / OpenClaw sessions without shared goals, locks, or budgets.
• Governance is still human work. “Zero-human company” is marketing framing. In practice operators spend time on goal quality, approvals, budget allocation, and skill files — higher leverage, not zero effort.

Community sentiment

Public reaction in 2026 is polarized but loud. On X and product pages, builders praise the Linear-like UX, multi-function org chart, and the “employee vs company” split with OpenClaw. Early essays describe Paperclip as the first open-source tool that treats multi-agent work as organizational design rather than prompt stacking, with stars climbing quickly after launch.

On Reddit (especially OpenClaw and solo-business communities), sentiment is more mixed. Supporters say budgets and a single dashboard beat twenty orphaned terminals, and that Paperclip + OpenClaw can complement each other. Critics call the dashboard “just show” when agent quality is weak, report CEOs ignoring issue comments or inventing real-world hiring processes, and argue a single strong agent with clear one-on-ones ships more product than a decorative org chart. Cost-control tutorials and YouTube deep dives focus on heartbeat cadence, model tiering, and skill design as the real levers.

Net: enthusiasts who already run multi-agent fleets tend to love the control plane; operators expecting autonomous revenue with minimal setup are often disappointed. Discord and GitHub Issues are the practical support channels for a self-hosted OSS product.

Who should use it

• Founders and ops leads coordinating 5+ agents across coding, research, content, and outreach who need budgets and audit trails.
• Teams already invested in Claude Code, Codex, Cursor, or OpenClaw who want one org chart and ticket system instead of ad-hoc session babysitting.
• Builders comfortable with Node, Postgres, and self-hosting who want MIT-licensed software they can inspect and extend via plugins/adapters.
• Portfolio experimenters running multiple isolated “companies” or templates (import/export) on one deployment.
• Not ideal for pure no-code users, single-chatbot use cases, enterprises needing a fully managed vendor SLA out of the box, or teams that only need deterministic workflow automation without agent org structure.

Alternatives

• OpenClaw — autonomous messaging-native “employee” agent; often paired under Paperclip rather than replaced by it.
• CrewAI — Python multi-agent framework focused on roles and task graphs in code, not a full company control plane UI.
• LangGraph / LangChain — developer frameworks for agent loops and stateful graphs you embed in applications.
• AutoGen — research-friendly multi-agent conversation patterns; more framework than board-level ops dashboard.
• n8n / Make / Zapier — workflow automation with triggers and connectors; better for deterministic integrations than org-chart agent companies.
• Dify — LLM app platform with agents and RAG; productized app builder rather than multi-runtime company OS.

Verdict

Paperclip is a real, actively developed open-source control plane for multi-agent work — not a fictional SaaS orchestrator with invented seat tiers. Its strength is the organizational layer: org charts, goal-traced tickets, atomic task ownership, hard budgets, and human board approvals on top of whatever agent runtimes you already use. Its weakness is the usual early OSS reality: you run the server, you pay the model bills, docs and agent bootstrap behavior still bite, and the “company” metaphor can mislead models into theatrics if skills and goals are sloppy.

Choose Paperclip when coordination, cost caps, and auditability across many agents are the bottleneck. Skip it when one well-prompted agent (or a simple automation tool) already ships the work. Bottom line: excellent concept and implementation direction for 2026 multi-agent ops; ROI depends almost entirely on how carefully you design goals, budgets, and skills — not on the dashboard alone.