What Paperclip Changes
Paperclip gives a collection of AI agents the operating structure that separate chat windows lack. It does not replace Claude Code, Codex, Hermes, Pi, OpenClaw, or a local model. It sits above them as a control plane: agents receive roles, managers, tasks, budgets, approval boundaries, recurring routines, and a shared audit trail.
NetworkChuck demonstrates that model by building an AI IT department. A Claude Code CEO delegates work to existing Hermes agents, Codex reviewers, and Pi agents using local models. Their test is wonderfully odd but operationally useful: investigate why activity around a studio toilet appears to disconnect editors from a network-attached storage system.
Use Paperclip when the coordination problem has become larger than the prompting problem. If you cannot tell which agent owns a task, what it changed, what it cost, why it stopped, or who approved the next action, a management layer can be more valuable than adding another model.
Watch the Demonstration
Credit: this workflow and creator test come from NetworkChuck's Paperclip walkthrough, published on 24 September 2026. The episode is sponsored by Flare. Product behavior and setup details were checked against the current Paperclip repository, official documentation, and NetworkChuck's companion guide on 26 September 2026.
How the System Fits Together
Paperclip describes itself as an open-source Node.js server and React interface for orchestrating agent teams. The distinction between the control plane and the workers is essential:
| Layer | Responsibility | Examples in the demo |
|---|---|---|
| Board | Approves hires and consequential decisions; can pause, resume, reassign, or terminate work | NetworkChuck |
| Paperclip | Stores goals, org structure, tasks, artifacts, routines, budgets, decisions, run records, and approvals | The company dashboard |
| Manager agents | Decompose work, delegate to specialists, resolve ordinary blockers, and escalate decisions | Claude Code CEO and Hermes CTO |
| Worker agents | Investigate, code, scan, analyze, or review through their native runtimes and tools | Hermes, Codex, Pi, local models |
| Adapters and gateways | Wake a runtime, pass task context, capture results, and report status back | Local adapters and the remote Hermes gateway |
Agents do not need to chatter continuously. Paperclip wakes them through short execution windows called heartbeats. A schedule, assignment, mention, manual invocation, or approval result can trigger a heartbeat. The runtime checks its identity and assignments, claims work, performs it, updates the issue, and returns to idle. Paperclip records the run, usage, cost, session state, and touched tasks.
This task-centered communication is healthier than an unbounded agent meeting. The conversation stays attached to an objective, and delegation remains visible through parent tasks, blockers, reviewers, approvers, and reporting lines.
The Mixed-Agent IT Team
The video deliberately mixes providers and machines. Existing Hermes agents keep the tools and skills already installed on their own virtual machines, while Paperclip gives them a common company identity and task protocol.
| Role | Runtime | Purpose |
|---|---|---|
| CEO | Claude Code | Plans the investigation, delegates tasks, combines evidence, and asks the board for decisions |
| CTO | Hermes | Coordinates the technical team and handles escalations before involving the human |
| Network engineer | Hermes | Maps switches, ports, links, events, and network behavior |
| Storage engineer | Hermes | Checks the NAS, storage health, and whether the storage system actually drops |
| Tooling engineer | Codex | Builds capture and diagnostic utilities for the investigation |
| Security reviewer | Codex | Challenges tooling and proposed actions from a security perspective |
| Scanner, help desk, watchdog | Pi with local models | Runs constrained checks, supports triage, and verifies stopped work |
The important design choice is specialization, not character names. Give each agent a narrow job description, the minimum tools needed for that job, a manager who owns escalation, and a budget that matches the value of its work.
A Safer Setup Path
Paperclip changes quickly. NetworkChuck's companion guide says the video was filmed on version 2026.831.1 and its written steps were retested on 2026.916.1. Treat the official documentation as the current source of truth when screens or commands differ.
1. Start locally
The current official quickstart requires Node.js 24.11 or newer and starts Paperclip at http://localhost:3100:
npx paperclipai onboard --yes
# Start it again later
npx paperclipai runThat local path uses an embedded PostgreSQL instance, so a separate database is not required for an initial test. The project also publishes a reviewed installer, source-clone workflow, Docker path, and server deployment documentation.
The official server guide recommends binding Paperclip privately and placing an authenticated HTTPS endpoint in front of it. For a first test, stay on loopback. For another machine, prefer authenticated private access, a VPN or tailnet, strict firewall rules, and short-lived credentials.
2. Create one company and one manager
Define a concrete company goal, then configure the first manager adapter. The runtime must already be installed and authenticated where it will execute. In the video, the first Claude Code run fails because Claude Code is not installed on the Paperclip server; after installation and login, retry succeeds.
3. Add one remote specialist
NetworkChuck onboards an existing Hermes agent by giving it Paperclip instructions and approving the resulting hire request. His separate remote gateway reference shows the general pattern: Paperclip creates a run, follows events or polls for completion, enforces a timeout, and collects the result. Use HTTPS or a private network, separate the gateway credential from the agent's Paperclip credential, and keep concurrency low during the pilot.
4. Prove delegation before adding the whole team
The first test is intentionally small: ask the CEO to assign a harmless task to the remote CTO and report back. Only after that round trip works should you add more runtimes, tools, secrets, and recurring jobs.
What the Toilet and NAS Test Actually Proved
The team receives one parent task containing the known symptoms. The CEO decomposes it into network, storage, security, scanning, and tooling work. Agents comment through task threads, generate downloadable artifacts, ask the human targeted questions, and create follow-up tasks as evidence changes.
The first report does not confidently blame the toilet. It finds that the NAS, router, spanning tree, and one suspected port do not explain the simultaneous disconnects. The useful clue is a physical pattern: four fiber links lose sync within seconds of one another, while storage remains online.
After more observation, the team identifies a batch of low-margin third-party SFP transceivers. The affected ports have dramatically more link-down events than a comparison port, and ordinary building movement appears capable of pushing the fragile links over the edge. NetworkChuck replaces the modules with vendor-branded units but correctly leaves the result open for another week or two of observation.
The agents narrow the fault domain, preserve evidence, recommend a reversible hardware change, and admit that the triggering event is not fully established. That is a better operational result than producing a confident story from a funny correlation.
The Controls That Matter More Than the Org Chart
Approval gates
An agent-requested hire can enter a pending state until a human approves it. Strategy, budget overrides, and sensitive actions can also be governed. In the demonstration, the board approves remote hires and answers decisions instead of letting the team silently expand its own authority.
Budgets and hard stops
Paperclip supports monthly or lifetime budgets, warning thresholds, agent-level tracking, and a company total. Its current documentation says the default hard-stop behavior pauses an agent at 100% until a board user raises the cap, resumes it, or the monthly window resets. Start with deliberately small limits; observed cost per accepted task should earn a larger allowance.
Artifacts and evidence
Reports, network maps, scripts, tests, screenshots, and other work products belong with the task. A completion status is weak evidence by itself. Review the artifact, the source data behind it, the action taken, and the verification result.
Routines
A routine turns repeated work into a scheduled, traceable task. NetworkChuck creates a daily storage check that reports capacity and asks for a decision when a threshold is crossed. His established Paperclip company also runs a daily standup where agents summarize work and question each other about unresolved dependencies.
Task watchdogs
A task watchdog does not merely ask whether a process is alive. It reviews a stopped issue tree and asks whether the stop is legitimate. Paperclip's execution documentation says it can inspect comments, artifacts, tests, screenshots, blockers, approvals, and run context. Within a deliberately limited scope, it may reopen or reassign stuck work, create follow-ups, repair blockers, or record why the final state is valid.
Scoped secrets and pause controls
In the sponsored segment, NetworkChuck stores Flare credentials as Paperclip secrets and grants them to a specific exposure-analysis agent. When that agent delegates actions too aggressively, the human can pause the work. The pattern is useful; the default should be narrower still: read-only access first, per-agent secret scopes, explicit approval for account changes, and immediate key rotation after a test.
A Practical First Pilot
- Choose a read-only problem. Inventory stale documentation, summarize monitoring alerts, classify support tickets, or audit a test environment.
- Write the acceptance evidence first. Define the report, screenshot, test, metric, or diff that will prove the task is complete.
- Use three roles. Start with one manager, one specialist, and one independent reviewer. A ten-agent org chart is not a prerequisite.
- Restrict the environment. Use test accounts, a lab network, read-only APIs, dedicated browser profiles, and reversible actions.
- Set tiny budgets. Add a warning threshold and a hard stop before the first meaningful task.
- Test the escalation path. Create an intentional blocker and confirm the worker asks its manager, the manager attempts resolution, and only then the human receives a precise decision.
- Challenge false completion. Attach a watchdog or reviewer and deliberately omit one required artifact to verify that the task is reopened.
- Add one routine last. Schedule a low-risk report only after the same task succeeds manually several times.
- Review the ledger weekly. Compare useful outputs, failed runs, spend, reviewer time, permission requests, and actions you had to reverse.
Who Should Use Paperclip?
| Situation | Recommendation | Why |
|---|---|---|
| One agent and occasional tasks | Keep the direct workflow | Paperclip adds more management than value |
| Several coding agents in one repository | Start with worktrees and code review; add Paperclip if ownership and cost remain unclear | Repository isolation solves a different problem from organizational control |
| Mixed runtimes across several machines | Strong pilot candidate | A shared task, budget, identity, and audit layer becomes useful |
| Recurring operational work | Use routines after manual validation | Schedules are valuable when outputs and escalation thresholds are measurable |
| Production writes, customer messages, payments, or account changes | Keep explicit human approval | The blast radius is too large for status-based trust |
| Regulated or highly sensitive environments | Run a formal security and compliance review first | Agent runtimes, logs, secrets, model providers, and remote gateways expand the data boundary |
Paperclip's strongest idea is not pretending agents are employees. It is making their work inspectable: every task has an owner, every delegation has context, every run has a record, every recurring job has a schedule, every budget can stop, and every consequential action can wait for a person.
Video Chapters
| Time | Topic |
|---|---|
| 00:00 | Why separate AI agents become difficult to manage |
| 01:32 | The AI IT department and mixed-harness plan |
| 06:09 | Install Paperclip and open the local dashboard |
| 06:48 | Create the Claude Code CEO |
| 08:33 | Hire a remote Hermes agent with board approval |
| 09:12 | Test manager-to-agent delegation through tasks |
| 10:27 | Claude Code, Codex, Hermes, Pi, and local models in one org chart |
| 11:30 | Launch the toilet and NAS investigation |
| 13:11 | Artifacts, diagnostics, and security review |
| 16:18 | Create a scheduled storage routine |
| 17:55 | Initial report and honest uncertainty |
| 18:59 | Deeper diagnosis identifies fragile SFP links |
| 21:15 | Replace the suspect transceivers |
| 23:17 | Scoped secrets and the sponsored Flare integration |
| 25:25 | Export the organization and run daily standups |
Resources and Sources
- NetworkChuck: you need to try Paperclip RIGHT NOW! (video and supplied transcript)
- Paperclip official website
- Paperclip GitHub repository (MIT licensed)
- Official Paperclip documentation
- NetworkChuck's Paperclip companion guide, prompts, and Flare skill
- NetworkChuck's remote agent gateway reference
- Dotta, creator of Paperclip
- NetworkChuck's Hermes agent setup video
- Try Flare through NetworkChuck's sponsor link
- NetworkChuck Academy
This article documents Paperclip and the creator workflow available on 26 September 2026. The project is developing quickly, so confirm installation commands, adapters, security settings, and deployment guidance in the current official documentation before operating a persistent instance.