Paperclip: Multi-Agent Orchestration for Zero-Human Companies
If OpenClaw is an employee, Paperclip is the company. A higher-level orchestrator that coordinates Claude, Codex, Cursor, Bash, HTTP, and OpenClaw agents into autonomous business operations with org charts, governance structures, and revenue-driven goals.
By Jose Nobile | Updated 2026-04-20 | 15 min read
What Is Paperclip?
Paperclip is a multi-agent orchestration framework designed to coordinate multiple AI agent types into cohesive, autonomous business operations. Launched March 2, 2026 and now at 53k+ GitHub stars with an MIT license, it is a TypeScript monorepo (Node.js server + React UI) that sits above individual agents like OpenClaw, treating them as specialized workers within a larger organizational structure. The latest release is v2026.416.0 (April 16, 2026), which introduced a standalone MCP server, blocker dependencies, and chat-style threads.
The core insight behind Paperclip is simple: if OpenClaw is an employee, Paperclip is the company. It does not replace individual agents -- it organizes them. Paperclip provides the management layer that assigns tasks, tracks progress, enforces governance policies, enforces per-agent budgets, and ensures that multiple agents collaborate toward shared business objectives through its heartbeat protocol.
Paperclip supports a wide range of agent types including Claude Code, Codex, Cursor, Gemini CLI, OpenCode, Hermes, Bash executors, HTTP webhooks, and OpenClaw instances. The "bring your own agent" philosophy means anything that can receive a heartbeat signal can be hired into the org chart. Paperclip's orchestration layer decides which agent handles which task based on capability matching, availability, and cost optimization.
Architecture
Org Charts
Define hierarchical agent structures that mirror real companies. A CEO agent delegates to department heads, which delegate to specialist workers. Each level has different authority scopes, budget limits, and escalation rules.
Governance Structures
Built-in governance rules control how agents interact, what decisions require approval, and how conflicts are resolved. Governance policies can enforce spending limits, require human approval for critical actions, or mandate peer review before deployment.
React UI
A full React-based dashboard for visualizing agent hierarchies, monitoring task progress, reviewing agent outputs, and managing governance policies. The UI provides real-time updates via WebSocket connections to the Paperclip server.
PostgreSQL Backend
All orchestration state -- task queues, agent assignments, execution logs, governance audit trails -- is persisted in PostgreSQL. This enables recovery from failures, historical analysis, and compliance auditing of all agent activities.
Multi-Agent Coordination
Coordinates Claude Code, Codex, Cursor, Gemini CLI, OpenCode, Hermes, Bash, HTTP, and OpenClaw agents simultaneously. Each agent type is registered with its capabilities, cost profile, and performance characteristics. The scheduler optimizes task assignment across the agent pool.
Skills System
A pluggable skills framework that extends agent capabilities at the orchestration level. Skills can span multiple agents -- for example, a "deploy to production" skill might coordinate a Codex agent for code review, a Bash agent for running tests, and an HTTP agent for triggering the CI pipeline. Company-scoped skill libraries were added in v2026.325.0.
Heartbeat Protocol
Every agent runs a heartbeat checklist at each session start: read identity, check plan, fetch assignments, execute, store memory, report. This solves the stateless agent problem -- agents that are capable but lose context between runs. Heartbeats can be scheduled or triggered manually via the CLI.
Budget Enforcement
Per-agent monthly budgets with automatic pause at 100% usage (warnings at 80%). Full cost tracking per task, project, and company. Real dollar tracking helps decide which tasks justify expensive models versus cheaper alternatives -- critical for preventing runaway costs in enterprise deployments.
The architecture follows a monorepo structure with clear separation between the server (orchestration engine), UI (React dashboard), packages (shared libraries), skills (pluggable capabilities), CLI (command-line interface), and docker (container configuration). This modular design allows teams to extend Paperclip without modifying the core orchestration logic. The plugin framework (added in v2026.318.0) enables runtime lifecycle management for third-party extensions.
Use Cases
Autonomous Business Operations
Run entire business workflows without human intervention. Agents handle customer inquiries, process orders, generate reports, manage inventory, and escalate only when governance rules require human approval.
Multi-Agent Task Delegation
Break complex objectives into subtasks and assign them to the most capable agent. A product launch might involve a Claude agent for copywriting, a Codex agent for landing page code, a Bash agent for deployment, and an OpenClaw agent for monitoring post-launch metrics.
AI Company Management
Model your entire company as an agent hierarchy. Define departments, roles, responsibilities, and reporting structures. Paperclip ensures that agent interactions follow the same organizational discipline that makes human companies effective.
Revenue-Driven Goals
Set high-level business objectives (e.g., "increase monthly revenue by 15%") and let the agent hierarchy decompose them into actionable tasks. Agents track KPIs, adjust strategies, and report progress through the governance framework.
Key Differences from OpenClaw
Business-Goal Oriented
Paperclip is designed around business objectives, org charts, and revenue targets. Tasks flow down from company-level goals through departments to individual agents. The focus is on organizational output, not individual assistant interactions.
Personal-Assistant Oriented
OpenClaw is designed for personal use -- one user, one assistant, multiple channels. It excels at personality design, conversational memory, and direct user interaction through messaging platforms like WhatsApp and Telegram.
Multiple Agent Types
Paperclip orchestrates diverse agent types (Claude, Codex, Cursor, Bash, HTTP, OpenClaw) in a single hierarchy. Each agent type is a specialized tool in the company's workforce, selected based on task requirements.
Single Agent Architecture
OpenClaw runs a single agent per node with deep integrations for messaging, voice, browser automation, and skills. It is the best choice when you need a rich, personal AI assistant rather than a multi-agent business system.
Paperclip and OpenClaw are complementary, not competing. Paperclip can use OpenClaw as one of its agent types -- deploying it as the "customer communication specialist" in a larger agent hierarchy. The combination gives you both the personal assistant depth of OpenClaw and the organizational orchestration of Paperclip.
OpenClaw Integration
Paperclip acts as a control plane around OpenClaw, structuring agent organizations, enforcing execution cycles, limiting budgets, and requiring human approval for high-impact decisions. The integration was formalized with the OpenClaw gateway adapter added in v0.3.0, which uses SSE streaming for real-time communication.
The connection occurs through a dedicated HTTP adapter built on Paperclip's webhook system. Four critical configuration fields control the integration: webhookUrl (gateway address, default http://127.0.0.1:18789), webhookAuthHeader (bearer token via secrets), payloadTemplate (routing metadata), and timeoutSec (response timeout, increase to 120-300 for heavy tasks).
Synchronous Pattern
For short tasks and decision-making heartbeats, the gateway returns results directly with a 2xx response. Orchestration metadata sits under a paperclip key while execution context (goals, task details, prior decisions) sits at the root level.
Asynchronous Pattern
For long-running coding work, the gateway acknowledges receipt with 202 Accepted and the agent calls back when finished. This is the primary pattern for most implementation tasks within the Paperclip org chart.
Org Chart Roles
OpenClaw agents operate within the Paperclip hierarchy with job titles and reporting lines. A CEO agent defines strategy, a CTO agent breaks it into technical tasks, and OpenClaw founding engineer agents execute implementation. Human operators act as "Board of Directors" through governance checkpoints.
paperclip heartbeat run --agent-id agent_cto_01
# Check session persistence (run twice to verify same session resumes)
paperclip heartbeat logs --run-id hb_run_7f3a
The eWeek article "Meet Paperclip: The Tool Turning OpenClaw Agents Into an AI Company" (March 10, 2026) covered this integration extensively, describing how Paperclip represents a paradigm shift from individual AI employees to autonomous AI companies. The combination gives you OpenClaw's personal assistant depth plus Paperclip's organizational orchestration.
Comparison with Alternatives
Paperclip occupies a different abstraction level than coding-first multi-agent frameworks. Where CrewAI, AutoGen, and LangGraph are Python libraries for building agent pipelines in code, Paperclip is a UI-driven dashboard application for managing agent organizations with org charts, budgets, accountability, and token tracking.
Paperclip
UI-driven orchestration with org charts, budgets, governance, and heartbeat scheduling. Agent-agnostic (bring any agent runtime). Focuses on business management, not pipeline engineering. TypeScript/Node.js. 53k+ GitHub stars.
LangGraph
Graph-based agent framework with explicit state machines. Highest production readiness with LangSmith observability, checkpointing, and streaming. Best MCP integration (tools become graph nodes). Python-first. Best for complex, stateful workflows needing time-travel debugging.
CrewAI
Role-based DSL with lowest learning curve. Deploys multi-agent teams 40% faster than LangGraph. Models agents as team members with roles and goals. Python-first. Best for rapid prototyping and internal tools where speed-to-demo matters.
AutoGen
Conversational agent teams using GroupChat coordination. Agents interact through multi-turn conversations. Every agent turn requires a full LLM call with accumulated history (4-agent debate with 5 rounds = 20+ LLM calls minimum). Python-first. Best for debate-style reasoning.
The key distinction: LangGraph, CrewAI, and AutoGen are developer tools for building agent pipelines in Python code. Paperclip is a management tool for running agent organizations through a dashboard. They can be complementary -- you could build individual agent logic with LangGraph and orchestrate the agents as a company through Paperclip.
Release History
v2026.416.0 (April 16, 2026)
Chat-style threads replace the classic comment timeline, powered by assistant-ui. Blocker dependencies let you set blockedByIssueIds on any issue -- Paperclip wakes the assignee when all blockers reach done. BETA standalone MCP server (@paperclipai/mcp-server) exposes the Paperclip API as an MCP tool server with approval creation. Board approvals with card styling in the issue detail sidebar. Auto-checkout for scoped wakes reduces agent heartbeat latency. Security: redacted Bearer tokens in logs, updated multer to 2.1.1 (HIGH CVEs) and rollup to 4.59.0 (path-traversal CVE).
v2026.403.0 (April 4, 2026)
Execution workspaces (experimental) with full lifecycle management for agent runs. New "Mine" inbox tab with mail-client keyboard shortcuts. Document revision history with restore capabilities. Anonymized telemetry (disable via DO_NOT_TRACK=1). Four additive database migrations.
v2026.325.0 (March 25, 2026)
Full company import/export with file-browser interface. Company-scoped skills library system. Routines engine with triggers and recurring tasks. Heartbeat settings improvements. This release introduced the foundation for the upcoming Clipmart marketplace.
v2026.318.0 (March 18, 2026)
Plugin framework with runtime lifecycle management. Issue documents and inline attachments. Hermes agent adapter support. Experimental execution workspaces first introduced. This release enabled third-party extensions to the platform.
v0.3.0 - v0.3.1 (March 9-12, 2026)
Initial major releases. Cursor, OpenCode, and Pi adapter support. OpenClaw gateway adapter with SSE streaming. PWA support with service worker. Gemini CLI adapter. Inbox read-state tracking. Worktree development tools. These releases established the multi-agent ecosystem.
Paperclip follows a date-based versioning scheme (YYYY.MDD.patch) since v2026.318.0. The upcoming Clipmart marketplace will allow downloading pre-built company templates: content agencies, trading desks, development shops, e-commerce operators, YouTube factories, and real estate operations -- all with org structures, agent configs, and skills baked in for one-click import.
Getting Started
The fastest way to get started is the one-command onboarding. Paperclip requires Node.js 20+ and pnpm 9.15+. The interactive setup handles database configuration (embedded PostgreSQL for local dev) and first company creation. No account required -- fully self-hosted.
npx paperclipai onboard --yes
# Or manual setup
git clone https://github.com/paperclipai/paperclip.git
cd paperclip
pnpm install
pnpm dev
# API runs at http://localhost:3100
The monorepo is structured into several key directories:
packages/
Shared libraries used across the monorepo. Includes core types, utility functions, agent interfaces, and the orchestration protocol definitions. These packages are consumed by both the server and the UI.
server/
The orchestration engine. Handles task scheduling, agent management, governance enforcement, and the PostgreSQL persistence layer. Exposes a WebSocket API for real-time communication with the UI and CLI.
UI/
The React dashboard for managing the agent hierarchy. Visualizes org charts, task queues, agent status, execution logs, and governance policies. Connects to the server via WebSocket for real-time updates.
skills/
Pluggable skill modules that extend orchestration capabilities. Each skill defines a multi-agent workflow (e.g., "code review pipeline", "content publication workflow") that the orchestrator can invoke as a unit. Note: third-party skills run with full filesystem and network access -- treat them like npm packages regarding supply chain risk.
CLI/
Command-line interface for managing the Paperclip instance. Create org charts, register agents, assign tasks, review governance logs, and monitor system health -- all from the terminal.
docker/
Container configuration for production deployments. Run Paperclip in Docker with PostgreSQL for reliable, reproducible setups across environments.
Enterprise Adoption
Paperclip hit 53k+ GitHub stars in under six weeks, making it one of the fastest-growing open-source AI projects of 2026. Adoption spans well beyond developer tools: security firms conduct automated audits, dental practices organize operations, roofing companies analyze satellite imagery for hail-damage leads, and marketing agencies delegate client work to agent hierarchies.
Agent Council (15 GPTs)
Aaron Sneed runs 15 custom GPT agents as a coordinated "council" with each agent having a specific role. The setup saves over 20 hours per week across operational functions including lead research, content drafting, data analysis, and social media management.
Felix Agent ($100K Revenue)
Nat Eliason built an autonomous AI agent called Felix using OpenClaw that handles content creation, research, and business development. It has earned over $100,000 in revenue with a target of $1 million -- demonstrating that agent-driven businesses can generate real income.
ROI Timeline
The cost of experimentation has collapsed -- small teams can now achieve 24/7 operations. However, ROI requires patience: the payoff comes in the second and third month, not the first week. Budget enforcement and governance controls are critical for keeping costs predictable during the ramp-up period.
Cost profiles vary significantly by approach: Claude Code Max subscriptions ($200/month) provide unlimited usage per agent, while API-based approaches can cost $450-$4,500 monthly for 10 agents running daily. Paperclip's per-agent budget tracking with automatic pause at 100% usage is essential for managing these costs at scale.
Known Issues
As of April 2026, Paperclip is maturing rapidly across five major releases. Known considerations include: EPERM symlink issues on Windows, agent permissions issues in certain configurations, and the experimental status of execution workspaces. The skills ecosystem lacks security sandboxing -- third-party skills run with full filesystem and network access, similar to npm's supply chain risk with a larger blast radius.
The project's TypeScript monorepo structure with strict typing catches many bug categories at compile time. The MIT license and active Discord community (with answer overflow archives) make it straightforward to get help and contribute fixes. Database migrations between releases are additive (no data loss), though teams should test upgrades in staging environments first.