How to Set Up Paperclip AI: The Complete Guide to Running Your Business on AI Agents

We run our entire company on Paperclip AI. Eleven agents, three live products, over 1,000 tasks completed in the first 8 days. We did not have a DevOps engineer set it up. We did not write custom orchestration code. We read the docs, made mistakes, and figured it out.

This is the setup guide we wish existed when we started.

What Paperclip Actually Is (And What It Isn't)

Before setup: a quick framing that will save you confusion later.

Paperclip is the control plane. It manages agent identity, task assignment, goal hierarchy, budgets, and approvals. It is not a model. It does not run your agents.

OpenClaw (or Claude Code, or Codex) is the execution plane. This is the actual AI process that reads tasks, uses tools, writes code, and does work. Paperclip tells agents what to work on. OpenClaw makes the agents work.

Most beginner content conflates these two. Paperclip is to OpenClaw what a project management system is to a software developer — it assigns, tracks, and coordinates, but it does not execute.

This distinction matters because your setup involves two separate installs: the Paperclip server (control plane) and the agent adapters (execution plane, one per agent).

Prerequisites

Node.js 18+ or Bun
A Claude API key (from console.anthropic.com)
Basic comfort with a terminal

You do not need Docker, Kubernetes, or any cloud infrastructure. Paperclip runs locally.

Step 1: Install and Onboard

npx paperclipai onboard

This command walks you through:

Creating your company
Setting up your first admin user (board member)
Configuring the local server
Starting the Paperclip dashboard

When it finishes, you will have a running Paperclip instance accessible at localhost:3100 (or your configured port). The dashboard is where you will do most of your management.

Step 2: Set Up Your Company Goal Hierarchy

Before you create agents, define what they are working toward. Paperclip's task system flows top-down:

Company Goal → Project → Issue → Agent Task

Create your top-level goal first:

paperclipai goal create \
  --title "Reach $5K MRR" \
  --description "First revenue milestone for the company"

Then create a project under that goal:

paperclipai project create \
  --title "Website and Content" \
  --goal-id <your-goal-id>

This hierarchy is not bureaucracy — it is context. When an agent works on a task, it can see all the way up to the company goal. That context shapes how it makes decisions. An agent that knows it is working toward "$5K MRR" will write content differently than one that just has a task titled "write blog post."

Step 3: Hire Your First Agent

This is where most guides stop being useful. "Hire an agent" sounds simple. In practice, you need to think about the agent's role, adapter type, and system prompt before you create it.

We use the claude_local adapter for all 11 of our agents — it runs Claude Code locally with Paperclip's skill system injected. Here is how we hired our content writer:

paperclipai agent hire \
  --name "Alex Rivera" \
  --role "Content Writer" \
  --adapter claude_local \
  --cwd /path/to/your/project

The cwd is the working directory the agent will have access to. For a content writer, that is your website repository. For an engineer, that is your codebase.

The system prompt is the most important thing you will write. Ours follow this structure:

[Role identity]
You are [Name], [Role] at [Company].

[Goals]
Your primary goal is [specific goal tied to company goal].

[Tools and access]
You have access to: [list of tools/files/APIs]

[Constraints]
Never: [hard limits]
Always: [required behaviors]

[Escalation rules]
If blocked or uncertain: [who to escalate to, how]

Do not make prompts longer than 2,000 words. We tried. Longer prompts make agents slower, not better. The escalation rules section is the one most people skip — it is the most important. Agents without clear escalation paths loop on blockers indefinitely.

Building an AI-powered team from scratch? We documented everything in our AI Agent Ops Guide →

Step 4: Connect OpenClaw

Each agent needs an execution process. For claude_local agents, that means running OpenClaw (or Claude Code) with the Paperclip skill installed.

Paperclip generates an OpenClaw invite prompt for each agent. The board pastes it into OpenClaw, and the agent's identity gets linked to its execution environment.

paperclipai agent openclaw-invite --agent-id <agent-id>

This outputs a ready-to-paste prompt that sets up the agent's skills, API keys, and company context in OpenClaw.

One process per agent. Each agent runs in its own terminal window (or process manager). We use a simple shell script to start all 11 at once. You can also use PM2 or systemd if you want proper process management.

Step 5: Configure Budgets

This is non-negotiable. Before any agent runs a single task, set a budget limit.

In the Paperclip dashboard, go to Company Settings → Budgets. Set:

Per-agent daily budget (we use $50–$100 depending on role)
Company-wide monthly cap
Alert threshold (80% triggers a pause for review)

Without budget limits, a looping agent can burn hundreds of dollars in hours. We know this because it happened to us in week one. An engineer agent got into a retry loop on a failing API call. $94 in 45 minutes. Budget caps prevent this. Set them before you give agents any tasks.

How We Structured Our Org Chart

Our current 11-agent setup:

| Agent | Role | Reports to | |---|---|---| | Jessica Zhang | CEO | Board | | Flora | Head of Product | Jessica | | Todd | Founding Engineer | Jessica | | Alex Rivera | Content Writer | Flora | | Sarah Chen | SEO Specialist | Flora | | Kai Nakamura | Graphic Designer | Flora | | Jordan Lee | Market Researcher | Flora | | Maya Patel | Growth Marketer | Flora | | Sam Cooper | Social Media | Flora | | Nate | Engineer | Todd | | Morgan Clarke | QA | Todd |

The reporting chain matters because Paperclip routes escalations through it. If Alex hits a blocker, the issue goes to Flora. If Flora cannot resolve it, it goes to Jessica. If Jessica cannot resolve it, it goes to the board (us, the humans).

This is the thing nobody tells you: the organizational design is the architecture. The chain of command in Paperclip determines how decisions get made and how blockages surface. Design it thoughtfully.

What Broke During Our Setup (And How to Fix It)

Problem 1: Agents working on tasks they do not have context for. Fix: Add parentId to every task. Agents that can see the parent task and grandparent project make dramatically better decisions.

Problem 2: No escalation rules in system prompts. Fix: Add a mandatory escalation section to every prompt. "If blocked for more than one heartbeat, update the issue to blocked and @mention [manager name]."

Problem 3: Budget not set, engineer agent looped. Fix: Set budgets before first agent run. Always.

Problem 4: All agents starting simultaneously with no tasks. Fix: Create a backlog of 20–30 starter tasks before you bring agents online. Agents with nothing to do do not idle gracefully — they sometimes hallucinate tasks or spin on tool discovery.

Problem 5: Circular dependencies between tasks. Fix: Use blockedBy field on issues to make dependencies explicit. Paperclip respects these and will not assign blocked tasks.

The Honest Assessment

After 8 days, our Paperclip setup is producing real work at real speed. 1,083 tasks completed. Six agents in error state at the last snapshot — mostly due to upstream blockers and process restarts, not model failures. Full benchmark data here.

Setup took about a weekend for the first 3 agents, and then another day per agent after that as we refined our prompts and workflow. The biggest time investment is not the technical setup — it is writing good system prompts and building a good task backlog.

If you are considering a similar setup, the Paperclip docs are solid. Our setup guide is here as a practitioner complement to them — the things you learn by doing, not reading.

Related reading:

Want someone else to run this for you? See our done-for-you AI operations services →