Paperclip: If OpenClaw Is the Employee, Paperclip Is the Company

"OpenClaw is an employee. Paperclip is the company."

This single tweet by @resolvervicky explains Paperclip better than any landing page:

▶️ "OpenClaw is an employee, Paperclip is the company."

We just ranted in another article about how most people miss the difference between a coding assistant (Claude Code) and agent infrastructure (OpenClaw). Paperclip now adds one more layer on top: what is actually the company these agents work in? For a broader inventory of what actually held up in the OpenClaw ecosystem, see the OpenClaw Audit 2026 and our six-month field report.

What is Paperclip?

Paperclip is an open-source control plane for autonomous AI companies. Self-hosted, MIT-licensed, written in TypeScript — and with roughly 59,000 GitHub stars in under two months, one of the fastest growing projects of the year.

The official pitch:

"The human control plane for AI labor. Hire AI employees, set goals, automate jobs and your business runs itself."

Setup is as brutally simple as OpenClaw:

npx paperclipai onboard --yes

Interactive setup for DB, auth and the first "company". No Paperclip account needed. Fully self-hosted.

Why bother? The problem with task tools

Linear, Jira, Asana — all built for humans. When your workforce is made of AI agents, a to-do list no longer cuts it:

• Who decides which agent takes which task?
• Who controls the token budgets before an agent hallucinates its way through $500?
• Who authorises an agent to "hire" another agent?
• Who sees in real time what 30 parallel agents are doing?
• Who owns the audit trail when the GDPR regulator asks?

That is exactly the gap Paperclip fills.

The architecture: two layers

Paperclip cleanly separates control from execution — a pattern we know from Kubernetes:

Core sentence from the docs: "The control plane doesn't run agents. It orchestrates them. Agents run wherever they run and phone home."

That is exactly the architecture you need when running multiple agent stacks in parallel — e.g. OpenClaw for internal ops and Claude Code for engineering tasks. If you are still unsure which layer does what, Make vs. Claude Code vs. OpenClaw has the clean decision matrix.

The five core concepts

Paperclip builds everything on five primitives:

1. Company

The company is the top-level unit. It has:

• A goal (e.g. "Build the #1 AI note-taking app at $1M MRR")
• Employees (all AI agents)
• An org structure (who reports to whom)
• A budget in cents
• A task hierarchy that traces back to the goal

A single Paperclip instance can run multiple companies in parallel.

2. Agents

Every employee is an AI agent with:

• Adapter type (how it runs — Claude Code, Codex, shell, webhook)
• Role + reporting (title, manager, direct reports)
• Capabilities (what it can do)
• Budget (monthly token limit)
• Status (active, idle, running, error, paused, terminated)

Strict tree hierarchy. Every agent has exactly one manager (except the CEO). That is the escalation and delegation path.

3. Issues (tasks)

Linear-style: title, description, status, priority, assignee, parent. Every task is linked to the company goal through its parent chain.

Lifecycle:

backlog → todo → in_progress → in_review → done
                      |
                   blocked

Atomic checkout: if two agents try to claim the same task at once, one gets a 409 Conflict. So you never have two agents wrestling with the same issue.

4. Heartbeats

Agents do not run continuously — they wake up on heartbeats. Triggers:

• Schedule (every X minutes)
• Assignment (new task)
• Comment (@mention)
• Manual (human clicks "invoke")
• Approval resolution (approval accepted/rejected)

Per heartbeat: identity check → read assignments → pick task → checkout → work → status update.

This is the fix for the classic "agent runs 24/7 and burns $2,000 overnight" problem.

5. Governance

Some actions require board approval (a human):

• Hiring — agents can ask for new reports, the board decides
• CEO strategy — the initial strategic plan needs approval
• Board overrides — the board can pause, terminate or reassign any agent

Every mutation ends up in an activity audit trail. That is exactly where compliance and GDPR requirements become livable.

Why this is exploding right now

Three reasons Paperclip pulled 59k stars in under two months:

1. The mental model is right. @yashns1 puts it well:

"CEO hires a Coder. You approve it. The mental model is a company you are running, not a tool you are using."

The shift from "I prompt an AI" to "I manage a team" changes everything.

2. The UX is at Linear level. @nummanali says: "Built with great taste i.e. design and UX quality like Linear etc." That is extremely rare in the open-source agent space.

3. It is agent-agnostic. No vendor lock-in. You can run Claude Code, Codex, OpenClaw, custom HTTP endpoints — all in parallel. Even OpenClaw alternatives like NanoClaw can be plugged in as adapters.

Where it sits (vs. Make, Claude Code, OpenClaw)

In Make vs. Claude Code vs. OpenClaw we described three layers of orchestration. Paperclip completes the picture:

Paperclip does not compete with OpenClaw or Claude Code. It sits above them.

Use cases we realistically see

Where Paperclip already makes sense today:

• Autonomous side projects: 5–10 agents build a SaaS, you play "the board"
• Content pipelines: research agent → writer agent → editor agent → publisher, all with goal tracking
• Outbound machines: lead research, personalisation, follow-ups — with a budget cap per agent
• Engineering teams: Claude Code agents as coders, one as reviewer, one as QA — with approval gates for production deploys

Where it does not belong: regulated core processes without a human decision owner. Even with an audit trail, an autonomous AI company is legally still you — with all liability that follows.

Our take

Paperclip is one of the few tools that thinks conceptually new. Not "better Zapier". Not "better coding agent". But: what if the org itself is software?

That is exactly what Jensen Huang meant when he stopped asking CEOs about their Claude strategy and started asking about their OpenClaw strategy. Anyone taking that seriously needs an answer to:

• How do agents access your systems? → OpenClaw / adapters
• How are they organised? → Paperclip org chart
• Who owns the budget cap? → Paperclip budgets
• Who approves critical actions? → Paperclip approvals
• Who sees the audit trail? → Paperclip activity log

That is the Claw strategy — and Paperclip is currently the most convincing piece of that puzzle.

Quick start

If you want to poke around in 5 minutes:

npx paperclipai onboard --yes

→ paperclip.ing · GitHub · Docs

---

Building an agent architecture and need someone who ties OpenClaw, Paperclip and Make together? Talk to us — we build exactly this kind of production-ready infrastructure.

More on the topic: "Claude Code killed OpenClaw" – myth · What is OpenClaw? · OpenClaw Audit 2026 · Half a year of OpenClaw – field report · Make vs. Claude Code vs. OpenClaw · OpenClaw in production (TillClawn 🤡) · OpenClaw self-hosting & GDPR · OpenClaw alternatives compared · Claude Code hidden features · Make error handling & retry strategies