What is Paperclip AI? The open-source agent org chart, explained

Paperclip AI vs the paperclip maximizer

Paperclip the product was open-sourced on March 4, 2026 by its creator, who goes by Dotta, with a post that read: "We just open-sourced Paperclip: the orchestration layer for zero-human companies" (X). The Startup Ideas Podcast introduced him as "the pseudonymous co-founder of Paperclip" (transcript). The code is MIT-licensed under Paperclip Labs, Inc., and as of October 2026 the paperclipai/paperclip repository on GitHub has more than 100,000 stars.

The older meaning comes from the philosopher Nick Bostrom. In a 2003 paper he described a badly specified AI goal producing "a superintelligence whose top goal is the manufacturing of paperclips, with the consequence that it starts transforming first all of earth and then increasing portions of space into paperclip manufacturing facilities" (Ethical Issues in Advanced Artificial Intelligence). That idea, usually called the paperclip maximizer or the paperclip problem, has nothing to do with the software beyond the name.

Paperclip is a control plane, not an AI agent

Paperclip does not come with a model or an agent of its own. Its docs say so plainly: "Paperclip is not an AI assistant you chat with. It's not a prompt tool or a coding helper" (Paperclip docs). Its architecture notes put the design rule in five words, "Control plane, not execution plane": Paperclip coordinates agents, it doesn't run them (architecture). The README sums it up as "If OpenClaw is an employee, Paperclip is the company."

Under the hood it is a Node.js server with a React web app and a PostgreSQL database, embedded by default. Agents connect through adapters. The built-in ones run Claude Code and Codex locally, launch a shell process or call an HTTP webhook, and the site lists Claude, Codex, Gemini, Cursor, Hermes, OpenClaw, Pi and OpenCode as agents you can bring (paperclip.ing). In Paperclip's words, "If it can receive a heartbeat, it's hired."

That split also decides where your data goes. The company record (tasks, documents, approvals, encrypted secrets) stays in Paperclip's database on your machine or server. The prompts, file contents and tool results each agent works with go to whichever model provider that agent uses (Paperclip open source page). If you want the general idea of a layer that coordinates many agents, our company harness explainer covers it; the rest of this post is about how Paperclip does it.

How does Paperclip AI work? A heartbeat, step by step

Paperclip agents don't run all the time. They wake up on a "heartbeat": on a schedule, when you start one by hand, or when something happens, such as a task being assigned to them or someone @-mentioning them (paperclip.ing). Each heartbeat follows the same six steps, as described in Paperclip's architecture docs:

Two details matter in practice. Every task has a single assignee, and an "atomic checkout" stops two agents from working on the same task at once. And because step 5 records the cost of every run, Paperclip can track spend per agent, which is what its budgets are built on.

Paperclip org chart, goals and context lineage

The org chart is the part people remember. Agents get roles and reporting lines: in Paperclip's words, "Your agents have a boss, a title, and a job description" (paperclip.ing). The usual start, per Paperclip's site, is to define a goal, hire the team starting with a CEO agent, review the CEO's strategy, set budgets and let it run. By default, the CEO can't hire more agents without your approval.

Goals are how Paperclip gives each agent its context. Work is nested from the company mission down to project goals, agent goals and single tasks, and the site says "Every piece of work is given context that traces back to the company mission." Agents also get skills, and a Paperclip SKILL.md that tells them how to find the context they need. One deployment can run "dozens of companies with complete data isolation between them."

The instructions themselves are files. One reviewer found his CEO agent ran on four markdown files, AGENTS.md, HEARTBEAT.md, SOUL.md and TOOLS.md, covering its role, what to do on each heartbeat, its tone and its tools (Jayadeep). The quality of those files turns out to matter a lot, as the limits section below shows.

The "zero-human company" framing is the bigger idea behind all this, and we cover it separately in what an autonomous company is. Dotta is candid about it himself: "the tagline is zero human companies. Now, I think that is maybe a bit aspirational" (podcast transcript).

Paperclip budgets, approvals and multi-user access

This is where Paperclip is stronger than its zero-human tagline suggests. People stay in charge by design, and the controls are real features, not plans:

• Budgets per agent. Every agent has a monthly budget. You get a soft warning at 80%; at 100% the agent pauses and new tasks are blocked, and you can override the limit and resume it (paperclip.ing).
• You are the board. "You operate as the board of directors. Agents can't hire new agents without your approval." The CEO agent also can't carry out a strategy you haven't reviewed, and you can pause or terminate any agent and reassign any task.
• Review and approval steps. Since the April 14, 2026 release, tasks can carry an execution policy with several review and sign-off stages, each with its own reviewers and approvers (changelog v2026.414.0).
• More than one human. The same release added multi-user access: invite links, company roles, approval of join requests, and real names for people in activity feeds, assignee pickers and @-mentions.
• A record of everything. Every task is a ticket, and Paperclip logs tool calls and decisions in what it calls an "Immutable audit log" (paperclip.ing).

Paperclip is also upfront about where these controls stop. Its own comparison table says "Recorded-cost budgets can overshoot; task review does not intercept every external call" (Paperclip open source page), and its FAQ says of the agents themselves, "your agents are your own and you secure them however you want to."

How to install Paperclip AI from GitHub

Paperclip is self-hosted and needs no Paperclip account. The steps from the README and the open source page:

1. Install Node.js 24.11 or newer.
2. Run npx paperclipai onboard --yes. To run from source instead, clone the repository and run pnpm install and pnpm dev (pnpm 9.15 or newer). Docker Compose works too.
3. Open http://localhost:3100. The default install is one Node process with an embedded PostgreSQL database and files under ~/.paperclip, in local_trusted mode bound to 127.0.0.1.
4. Connect at least one agent runtime. The docs walk you through getting an API key from Anthropic or OpenAI.

Two things to know before you start. The software is free, but the agents are not: the docs warn that an active agent team can spend $20 to $100 or more a month in model provider charges, "depending on how many agents you run and how often they work" (Paperclip docs). And anonymous usage telemetry is on until you turn it off. As of October 2026 the latest stable release is v2026.1023.0, from October 23. A hosted version has a waitlist that says "Paperclip is rolling out gradually", with no published price.

Paperclip AI limits: costs, setup and security

The public reviews I read agree on the idea and disagree on how ready it is. These are the recurring limits:

• Heartbeats cost money even when nothing ships. One tester's two-agent team kept "checking tickets in and out, burning credits through heartbeat checks and status polls", while "no real output was being produced" (Open Source is Better).
• New agents start with thin context. When the CEO agent hired an engineer, "its AGENTS.md was just two lines explaining its role", and things only started working much better once the reviewer wrote the same four instruction files for it himself. His verdict: Paperclip "is not a plug-and-play system yet" (Jayadeep).
• The org chart is a metaphor. The same reviewer advises: "The org chart with a CEO, CFO, CMO, and so on is mostly a marketing device." He suggests treating Paperclip as a way to manage several independent agents.
• Security needs your attention. As of October 2026, Paperclip's GitHub repository lists 12 security advisories, five of them rated critical (advisories). The worst, CVE-2026-41679 (CVSS 10.0), let an unauthenticated attacker run code on a network-reachable instance in authenticated mode with the default settings; it is fixed in 2026.416.0 (advisory). Another (CVSS 9.6) allowed a malicious web page to run commands on a developer's machine through a local instance in the default local_trusted mode, using DNS rebinding (advisory; Infosecurity Magazine). Jayadeep's advice: "I would not run this on my local laptop."

None of that makes Paperclip a bad idea. It makes it a young, fast-moving open-source project: keep it on the current release, don't expose an instance you haven't configured for authentication, and give agents only the access their job needs.

Shared context before isolated agents: where Koru Squads fits

The reviews point at something Paperclip's goal lineage only partly solves. Each task knows which goal it serves, but each agent still works from whatever instructions and files it was given, and a two-line AGENTS.md makes a weak employee however good the org chart looks.

That's the problem we're designing Koru Squads around. Squads is in development and not available yet. The idea on the Squads page is "Give your company a brain before you give it agents": persistent squads of humans, agents or both work from shared, evolving company context, hand work to each other with the context retained, and come to people at clear human checkpoints. The first line of what we're building toward is "Shared context before isolated agents."

If that matches how you want to work with agents, join the Koru Squads waitlist. For the bigger picture of people and agents sharing context, read what multiplayer AI is.

Frequently asked questions