What Is Paperclip? The Open-Source OS for Multi-Agent Companies

What Is Paperclip?

Paperclip is an open-source platform that orchestrates teams of AI agents to run business operations. It consists of a Node.js server and a React-based dashboard that let you bring your own AI agents, assign them goals, track their work, and monitor costs — all from a single interface.

The project is available on GitHub at github.com/paperclipai/paperclip under the MIT license, with an official site at paperclip.ing.

Created by pseudonymous developer @dotta, Paperclip launched on March 2, 2026 and crossed 38,000 GitHub stars within its first month — making it one of the fastest-growing AI agent projects of 2026. The velocity reflects a real demand: teams were building multi-agent systems by duct-taping individual agents together, and Paperclip provided the coordination layer they were missing.

The simplest way to understand Paperclip: if individual AI agents like OpenClaw are employees, Paperclip is the operating system that manages the entire company. It handles task assignment, progress tracking, budget enforcement, and inter-agent coordination so that multiple AI agents can work together on complex business operations.

How Does Paperclip Work?

Paperclip's architecture is deliberately simple. The system has three main components:

1. Node.js Server — the backend that manages agent registration, task queuing, budget enforcement, and state persistence. It exposes a REST API that agents use to check in, receive assignments, and report progress.
2. React Dashboard — a web-based UI where operators define company goals, assign tasks to agents, monitor progress, and track costs in real time. The dashboard provides a single pane of glass for the entire multi-agent operation.
3. Agent Interface — a standardized protocol that any AI agent can implement to join the Paperclip system. Agents register with the server, receive task assignments through a heartbeat mechanism, execute tasks, and report results back. The interface is agent-agnostic — OpenClaw, Hermes Agent, custom agents, or any other framework can participate.

The workflow operates on a heartbeat model. Each agent periodically checks in with the Paperclip server ("heartbeat"), receives any pending task assignments, works on them, and reports progress or completion at the next heartbeat. This architecture allows Paperclip to coordinate agents running on different machines, different networks, or even different cloud providers — as long as they can reach the Paperclip server's API.

Context persistence across heartbeats means that if an agent crashes, restarts, or gets reassigned, the Paperclip server maintains the full context of what was happening. The agent can resume work from its last checkpoint without losing progress.

What Are Paperclip's Key Features?

Bring Your Own Agents

Paperclip is agent-agnostic. It does not include its own AI agent — instead, it provides the coordination layer for agents you already have. Any agent that implements the Paperclip heartbeat protocol can join the system. This means you can mix and match different agent frameworks: one OpenClaw instance for customer support, one Hermes Agent for research, and a custom Python agent for data processing — all coordinated through the same Paperclip dashboard.

Goal Assignment and Tracking

Operators define high-level goals through the React dashboard (e.g., "process all incoming support tickets," "generate weekly financial reports," "manage social media content calendar"). Paperclip breaks these goals into tasks and assigns them to appropriate agents based on their capabilities and availability. Progress tracking happens in real time through the dashboard.

Cost Tracking and Budget Enforcement

Every task in Paperclip has cost tracking built in. The system monitors LLM token usage per agent per task, calculates costs in real time, and can enforce budget limits at the task, agent, or company level. If an agent approaches its budget ceiling, Paperclip can pause the task, alert the operator, or reassign it to a lower-cost agent.

Atomic Execution

Paperclip implements atomic task execution through a checkout system. When an agent picks up a task, the task is locked — no other agent can claim it simultaneously. This prevents duplicate work, ensures clean ownership, and makes it easy to track which agent is responsible for which outcome. If an agent fails to complete a task within its timeout, the lock releases and the task becomes available for reassignment.

Context Persistence Across Heartbeats

Agent context survives across heartbeat cycles, restarts, and reassignments. The Paperclip server maintains a persistent state store for each agent, so work can resume seamlessly after interruptions. This is critical for long-running tasks that span multiple heartbeat cycles — the agent picks up exactly where it left off.

Dashboard Visibility

The React dashboard provides real-time visibility into the entire multi-agent operation: which agents are active, what tasks are in progress, how much each agent has spent, which goals are on track, and where bottlenecks are forming. For operators managing multiple AI agents, this single-pane view replaces the fragmented monitoring of individual agent logs.

What Are Zero-Human Companies?

The concept that put Paperclip on the map is the "zero-human company" — a business where all operational tasks are handled by AI agents, with humans involved only at the strategic decision-making level.

This is not science fiction or marketing hype. The idea is straightforward: if individual AI agents can already handle specific business functions (email triage, content creation, data analysis, customer support, scheduling), then a coordination layer like Paperclip can organize those agents into a functioning team that operates a business.

In a zero-human company setup with Paperclip:

• A CEO agent sets priorities and allocates resources across the team.
• A sales agent handles lead qualification, outreach, and follow-up.
• A support agent manages customer inquiries and issue resolution.
• A content agent produces blog posts, social media content, and marketing materials.
• A finance agent tracks revenue, costs, and generates financial reports.
• A operations agent handles scheduling, vendor management, and internal coordination.

Each agent runs independently, receives task assignments from Paperclip, and reports results back to the dashboard. The human founder reviews the dashboard periodically, makes strategic decisions, and adjusts goals — but the day-to-day execution is handled entirely by the agent team.

This model is still early. Most teams using Paperclip today run 3-5 agents handling specific workflows rather than fully autonomous businesses. But the architecture supports scaling to larger teams, and the 38,000+ GitHub stars suggest significant interest in the direction.

Real-World Example: 14 AI Agents Running a Company

One of the earliest public case studies of Paperclip in action involved a team that built a company powered by 14 AI agents. Each agent handled a distinct business function — from product development to customer acquisition to financial operations — coordinated entirely through the Paperclip dashboard.

The setup demonstrated several practical realities of multi-agent orchestration:

• Specialization works — agents performing narrow, well-defined roles produced better results than general-purpose agents trying to handle everything.
• Cost control matters — without Paperclip's budget enforcement, the 14-agent team would have burned through LLM credits rapidly. Per-agent budgets kept costs predictable.
• Coordination is the hard part — the individual agents were not difficult to set up. Getting them to work together without duplicating effort, dropping tasks, or producing conflicting outputs required the orchestration layer.
• Visibility changes behavior — having a single dashboard showing all 14 agents' activity in real time allowed the founding team to identify and fix bottlenecks that would have been invisible in a log-based monitoring setup.

This kind of multi-agent deployment is where Paperclip shines — and where it complements single-agent frameworks like OpenClaw. OpenClaw excels at making one agent extremely capable. Paperclip excels at making multiple agents work as a team.

How Does Paperclip Compare to OpenClaw?

Paperclip and OpenClaw solve different problems and operate at different levels of the AI agent stack. They are complementary rather than competing.

The most practical way to think about it: OpenClaw is the agent that does the work. Paperclip is the system that coordinates multiple agents doing different work. If you are running a single AI assistant, you need OpenClaw (or a similar agent runtime). If you are running a team of AI agents, you need Paperclip (or a similar orchestration layer) on top.

Many operators start with a single OpenClaw agent, expand to multi-agent OpenClaw setups, and eventually add Paperclip when they need more sophisticated coordination, cost tracking, and dashboard visibility across their agent fleet.

For context on how OpenClaw compares to other agent frameworks, the OpenClaw alternatives guide covers the full landscape.

How Do You Get Started?

Paperclip is self-hosted and runs on any machine with Node.js. The basic setup:

1. Clone the repository from github.com/paperclipai/paperclip.
2. Install dependencies — standard Node.js setup with npm install.
3. Start the server — the Paperclip server and React dashboard start together. The dashboard is accessible through your browser.
4. Register your agents — connect your existing AI agents (OpenClaw, Hermes, custom agents) to the Paperclip server using the heartbeat protocol. Each agent needs the server's API endpoint and an authentication token.
5. Define goals — use the dashboard to create company goals and task definitions. Paperclip will begin assigning tasks to registered agents.
6. Monitor and adjust — watch the dashboard for agent activity, cost tracking, and goal progress. Adjust budgets, reassign tasks, and modify goals as needed.

The entire setup process is faster than most agent frameworks because Paperclip is not an agent itself — it is an orchestration layer. The complexity is in configuring your individual agents, which you likely already have running.

Hosting costs for Paperclip are minimal since it is a lightweight Node.js server. A $5-10/month VPS handles the Paperclip server and dashboard comfortably. The real costs are the LLM inference for each agent in your team. For cost optimization strategies, the OpenClaw token cost optimization guide applies equally to agents running under Paperclip.

Community and Resources

Paperclip's community grew rapidly alongside its GitHub star count:

• Official GitHub — github.com/paperclipai/paperclip for source code, issues, and discussions.
• Official site — paperclip.ing for documentation, guides, and updates.
• Remote OpenClaw community — the Skool community includes operators using Paperclip alongside OpenClaw for multi-agent setups.

As Paperclip matures, expect more integrations with established agent frameworks. The agent-agnostic architecture means any framework that implements the heartbeat protocol can participate — which positions Paperclip as a potential standard for multi-agent coordination.

Frequently Asked Questions

Is Paperclip free?

Yes. Paperclip is open source under the MIT license and completely free to use. You self-host the Node.js server and React dashboard on your own infrastructure. The only costs are LLM inference (API calls to Claude, GPT-4, or other providers used by your agents) and hosting for the Paperclip server itself — typically $5-10/month for a basic VPS.

Can I use Paperclip with OpenClaw?

Yes. Paperclip orchestrates teams of AI agents, and OpenClaw agents can be individual members of that team. Paperclip handles the coordination layer — assigning goals, tracking progress, enforcing budgets — while each OpenClaw instance handles its own messaging, memory, and task execution. The two tools are complementary. Operators who already run multi-agent OpenClaw setups often add Paperclip for the dashboard visibility and cost tracking it provides.

What's the difference between Paperclip and OpenClaw?

Paperclip is a multi-agent orchestration platform — it coordinates teams of AI agents working together on business operations. OpenClaw is a single always-on AI agent with persistent memory and messaging integrations. Paperclip is the manager that assigns work and tracks costs across a team. OpenClaw is the individual worker that executes tasks autonomously. Most teams that need both start with OpenClaw for individual agent capabilities and add Paperclip when they scale to multiple agents.