Paperclip AI Gives Your AI Agents Jobs. Who Checks the Work?

What is Paperclip AI?

Paperclip AI coordinates agents as a team, with an organisational structure, work assignments and management controls. You define what the team should achieve, connect the agents that will do the work, and use a shared interface to follow progress and intervene.

The project’s repository captures its ambition in one sentence: “If OpenClaw is an employee, Paperclip is the company.” That means the organising layer around an agent: the goals it serves, the work it receives and the people or agents reviewing its decisions.

The README is blunt about the pitch: “Manage business goals, not pull requests.” Its example goal is “Build the #1 AI note-taking app to $1M MRR”, and its hiring policy fits in one line: “If it can receive a heartbeat, it’s hired.” By 24 September 2026 the repository had passed 81,000 stars and nearly 15,000 forks.

This matters when your current workflow involves copying answers between windows. One assistant researches, another writes, and you keep reminding both what the other discovered. The organisation exists in your head. Every interruption makes you reconstruct its decisions, context and unfinished work.

Is Paperclip AI the paperclip maximizer?

No. The paperclip maximizer is a thought experiment from philosopher Nick Bostrom, who described a superintelligence “whose sole goal is something completely arbitrary, such as to manufacture as many paperclips as possible”. Paperclip AI is an unrelated open-source app for managing agent teams. The name makes the confusion inevitable, which is why so many searches for one land on the other.

The toilet problem, and what the agents actually found

At NetworkChuck Studios, anyone flushing the toilet seemed to knock everyone off the NAS, the shared network storage. So in the video, published on 24 September 2026 as “you need to try Paperclip RIGHT NOW!”, he built an all-agent IT department to find out why.

The org chart was deliberately mixed. A CEO called Dumbledore ran on Claude Code. Three existing Hermes agents joined as CTO, network engineer and storage engineer. Codex ran a security reviewer, and several helpers, including a network scanner, ran on the Pi harness with local models.

The CEO split the ticket into tasks and handed them out. One agent logged into the switches and mapped the network, others checked the storage and the timing of each drop, and anything that needed a human landed in Chuck’s inbox as a decision to make.

Their first report was admirably honest: they could not name the trigger. A flush fitted the evidence, they said, “but so would a door, HVAC compressor cycling, or someone’s chair hitting the cabinet”. What they could show was four fibre links dropping within two seconds of each other, 36 times in a week.

The final verdict: not the toilet. Four links on one switch had been misbehaving for 15 months, all fitted with cheap third-party transceivers from one batch that, by the agents’ count, had a 50% in-service failure rate. Chuck swapped in official MikroTik modules. He still blames the toilet: “It’s a better story, anyway.”

That is the transferable part of the experiment. Businesses already have problems with suspicious patterns: orders that fail after a particular handover, stock figures that change overnight, or invoices that get stuck with one supplier. Each needs investigation before anyone changes the process.

How does Paperclip get AI agents working together?

Paperclip connects agent runtimes through adapters and gives their work shared structure. Each agent still needs its own configured tools, credentials and working environment. The management layer makes assignments visible; the connected runtime determines what the agent can actually do with them.

NetworkChuck calls it a “meta harness”: it does not replace Claude Code, Codex or Hermes, it employs them. Agents talk to each other through tasks rather than open chat, on purpose. As Paperclip’s creator, Dotta, put it in the video: “I haven’t seen a lot of super value out of like agent conference room or an agent town where you just set your agents to sit there and talk to each other.”

Claude Code

Claude Code is Anthropic’s agent runtime for working with code and files. Paperclip’s Claude Code adapter can launch it with an assigned working directory and preserve session continuity between runs. That makes it a candidate for implementation or investigation tasks with concrete files to inspect. A CEO title describes its assigned role, however; it does not establish that its plans are correct or that it should receive unrestricted access.

Hermes

Hermes Agent is an agent system from Nous Research with persistent memory, tools and support for multiple model providers. Paperclip’s Hermes adapter documentation describes a built-in local integration. The attraction is continuity: an existing agent can bring useful capabilities into a managed workflow. You still need to check what information its memory contains, which tools are available and whether its access fits the particular job you are assigning.

Codex

Codex is OpenAI’s coding agent runtime. The documented Paperclip Codex adapter runs the CLI and maintains session state across agent runs. For a mixed team, it offers another runtime for implementation or review. Using a different agent for the second pass can be useful, but a different name on the review does not prove independence. Give the reviewer explicit checks and access to the underlying evidence.

Paperclip adapters

Adapters are the connection between Paperclip’s assignments and the software executing them. The official adapter guide explains how they launch an agent, pass it work and receive its results. This distinction helps when comparing setups: a model supplies inference, a runtime gives it tools, and Paperclip coordinates the work. Choose the combination around the task and the access it needs, then verify that the connection works before expanding the team.

You can make an organisation chart look impressive very quickly. A more useful starting point is one worker with a clear assignment and someone responsible for reviewing it. Add another role when you can explain the specific handover or capability it improves.

Tasks give the team something to finish

Paperclip represents work as issues, which its task documentation also calls tasks. These connect an assignment to the wider goal and provide a place to track it. That shared record becomes valuable when several agents contribute at different times to one outcome.

Consider an illustrative purchasing workflow. A business wants to know why a replenishment recommendation looks wrong. One agent checks demand inputs; another reviews supplier lead times. A useful assignment says which records to inspect, where to leave findings and how uncertainty should be reported.

Our guide to calculating safety stock explains why the underlying inputs matter. An agent can help investigate or explain a calculation, but the business still needs an agreed method and current records. Coordination does not repair an undefined inventory policy by itself.

Good task design also makes failure easier to understand. A blocked assignment should say what is missing and who can provide it. A finished assignment should point to its output. Those are simple requirements, but they make a team much easier to manage.

Routines keep repeat work attached to a purpose

Paperclip distinguishes agent wakeups from recurring jobs. Its routines documentation describes scheduled or webhook-triggered work that creates or reopens a task and wakes the assigned agent. That gives repeat work a defined reason to run and a record you can inspect afterwards.

The same documentation says timer heartbeats are off by default for new agents. That is a useful design choice: an agent repeatedly checking whether anything needs doing can consume resources without producing an outcome. Event-driven work starts from an actual assignment or relevant change.

For example, a daily routine could prepare a report of purchase orders whose promised delivery dates have passed. The useful output is a short exception list linked to the affected records. A human can then decide which suppliers need a follow-up or escalation.

NetworkChuck runs his daily stand-up this way: a 5pm routine where each agent reports what it did and asks the others about anything unclear. A daily storage check he set up in the video came straight back with a decision for him, because SSD capacity was running low.

Start by choosing a cadence the business can act on. An hourly report has little value if someone reviews it once a week. Decide who receives the result, what deserves attention and how repeated alerts will be handled before increasing the frequency.

Can Paperclip tell when an agent is really finished?

Paperclip can enforce review stages and ask another agent to check stopped work, but the quality of that judgement depends on the evidence and review criteria. A task status records a decision; you still need a sound basis for accepting the result.

The execution policy documentation describes a concrete control: when an executor tries to finish an issue, the runtime can route it through configured review and approval stages. The handover is enforced by the system, so it need not rely on a reminder inside the prompt.

Paperclip also documents task watchdogs, which are optional agents assigned to inspect a stopped issue and its descendants. They can check whether the work is actually finished, whether a blocker is real and whether a continuation needs to be restored to move it forward.

A watchdog is useful when an agent gives up prematurely or claims completion without enough evidence. Long-running agents can stall in ways that look like progress, as GPT-6 Astra showed when it spent hours farming potatoes in Minecraft after losing its chest. Its own decision remains something to examine. A second agent can inherit the first agent’s mistaken assumptions, particularly if both see the same incomplete description of the problem.

The video shows why these controls matter. When Chuck gave a new agent access to a threat-intelligence service, it found exposed credentials and had another agent start forcing password resets, work he had not asked for. He paused it from the task view. Blockers, by contrast, went up the chain: to the CEO agent first, then to him.

For your first workflow, write the acceptance criteria before the assignment runs. Require source references, identify checks that can be reproduced and name the person handling ambiguity. You will learn more from a modest task with a clear finish than from an elaborate hierarchy.

What does Paperclip AI actually cost?

Paperclip’s open-source software is available under the MIT licence, while the agents you connect may incur provider charges or consume local computing resources. Your practical cost also includes the time spent configuring, supervising and correcting the workflow. Measure all of those against accepted output.

The documented budget controls include company and individual agent limits, with warnings and automatic pausing at the stated thresholds. Treat that as a way to manage recorded spending. Check how your chosen adapter reports usage and compare the totals with the provider’s own account records.

Local models change the cost structure rather than eliminating it. Hardware capacity, electricity and maintenance still matter, as does the time a task takes. A cheaper run has limited value if its output needs extensive checking or the agent repeatedly fails the assignment.

Track a small set of useful measures during a pilot: accepted tasks, corrections, human review time and total spend. Compare those with the existing process over similar work. The decision to expand should come from that comparison, with enough detail to explain disappointing results.

Start with one workflow you can judge

Choose a recurring problem with identifiable inputs and an output someone already knows how to review. An exception report, a draft reconciliation or an investigation brief can work as a starting point. Keep the assignment narrow enough that you can see where effort is saved.

The table below suggests an initial approach by task shape. It is an editorial decision guide, not a benchmark of competing products. The aim is to match the amount of coordination to the work, so each extra component has a clear reason to exist.

Follow the official installation guide for your environment, then connect one runtime and test a bounded assignment. Avoid turning setup into an infrastructure project before you have an example worth repeating. The first milestone is an output you can inspect and judge against its brief.

Pay attention to where the service is available. Paperclip’s deployment documentation distinguishes a trusted local mode from authenticated deployments. Choose the appropriate mode before sharing access with colleagues or exposing the service across a network, and check which account permissions each agent inherits.

Give the pilot access to a controlled copy or a suitable read-only view of the relevant records. Start with producing recommendations for review. Expand its authority after you have seen how it handles incomplete data, conflicting instructions and an assignment it cannot finish.

For operations work, the data structure deserves equal attention. A stock investigation needs agreed product identifiers and transaction records. Manufacturing work may also depend on a clear bill of materials. Agents will struggle to reconcile information when the underlying business definitions keep changing between systems.

Frequently Asked Questions

Is Paperclip AI a new AI model?

Paperclip is software for coordinating agents. It connects to runtimes that use models to perform work, then provides shared goals, tasks and management controls. Your choice of connected runtime, model and tools determines much of what an individual agent can accomplish.

Does Paperclip work with Claude Code, Codex and Hermes?

Yes. Paperclip documents adapters for Claude Code, Codex and Hermes. Each connection has its own configuration and runtime requirements. Confirm the appropriate setup for where your agent runs, then test a small assignment before relying on it inside a wider workflow.

Can Paperclip run with local models?

Yes, through a compatible agent runtime. NetworkChuck ran several of his agents, including a network scanner and a help desk agent, on the Pi harness with local models. Check the chosen runtime’s provider support, tool behaviour and hardware requirements before planning around that arrangement.

Can an AI agent approve another agent’s work?

Yes. Paperclip’s execution policies allow agent reviewers and human participants in configured review or approval stages. Decide which decisions need a person, and give every reviewer explicit acceptance criteria. A completed approval step should be supported by evidence you can inspect.

Is Paperclip AI free?

Yes, the software is free and open source under the MIT licence. The agents you connect are not necessarily free: hosted models charge for usage, and local models cost hardware and electricity. Budget for setup and supervision time as well as the running costs of each agent.

Is Paperclip AI related to the paperclip maximizer?

No. The paperclip maximizer is Nick Bostrom’s thought experiment about an AI pursuing an arbitrary goal, making paperclips, to extreme lengths. Paperclip AI is a separate open-source project for coordinating teams of AI agents with goals, tasks and budgets. The shared name is the only connection.

Can Paperclip run my business without supervision?

You should evaluate it as a system for delegating defined work under controls. The documentation and video description do not establish reliable, unsupervised operation of an entire business. Start with a bounded workflow, judge its outputs and retain responsibility for consequential decisions.

Final takeaway

Paperclip makes agent teamwork more concrete by giving work owners, records, budgets and review stages. Its value will show up in tasks your business can accept with less effort. Start with a problem you can measure and make the evidence easy to inspect.

Give your AI team a reliable business system

In the systems we build, orders, stock, purchasing and production need clear records and accountable workflows. OpsMavix builds custom operational systems and full ERPs around those needs, so AI can work from information the business understands. Our system demos show examples of that foundation.

Keep business truth in a system you own and make the AI layer replaceable. Then an agent can help investigate an exception, prepare a recommendation or explain a change while your records, permissions and approved processes remain the foundation for everyday operations.

See what an ERP built around your business could look like →

Book a free Operations Leak Audit