Paperclip: When You’re the CEO of a Company With No Employees — Only AI Agents

What Is Paperclip? From Chatbot to Company

Definition

Paperclip is a Node.js server and React UI that lets you orchestrate a team of AI agents to run a business. If OpenClaw is an employee, Paperclip is the company that hires them.

Design philosophy: "Manage business goals, not pull requests. You are the board, not the day-to-day manager."

The Core Difference

Most AI tools focus on making one agent smarter. Paperclip focuses on making many agents work together effectively.

Technical Specifications

Tech Stack

• Backend: Node.js 20+

• Frontend: React (dashboard UI)

• Database: PostgreSQL (embedded or external)

• Package manager: pnpm 9.15+

• License: MIT (open-source)

• Deployment: Self-hosted (local, VPS, or cloud)

• API: REST API at localhost:3100

• Mobile: Responsive web UI (no separate app)

Supported Agents

• OpenClaw: Autonomous agent framework (Python)

• Claude Code: Anthropic's coding agent

• Codex: OpenAI's code generation

• Cursor: AI-powered code editor

• Bash scripts: Custom automation

• HTTP agents: Any agent with an HTTP endpoint

Important: Paperclip doesn’t create agents. It orchestrates the agents you already have. Bring Your Own Agent (BYOA).

Core Features: 9 Things That Make Paperclip Different

1. Org Chart for AI Agents

Define roles, reporting lines, and responsibilities just like a real company. Each agent knows its scope and who it reports to.

Sample org chart:

CEO (Claude Opus)
├── CTO (GPT-4)
│   ├── Senior Engineer (Claude Sonnet)
│   ├── Junior Engineer (GPT-4o-mini)
│   └── DevOps (Bash scripts)
├── CMO (Claude Sonnet)
│   ├── Content Writer (GPT-4)
│   ├── SEO Specialist (Claude Haiku)
│   └── Social Media Manager (GPT-4o-mini)
└── CFO (Claude Haiku)
    └── Accountant (Bash scripts)

2. Budget Enforcement

Set monthly spend limits per agent or department. Paperclip automatically throttles agents as they approach limits, preventing runaway costs.

Example budgets:

• CEO: $200/month (strategic decisions, few calls)

• Engineers: $500/month each (heavy code generation)

• Content Writer: $300/month (heavy text generation)

• Company total budget: $2,000/month

When an agent hits 80% of its budget, Paperclip sends a warning. At 100%, the agent automatically pauses until next month.

3. Goal Alignment

Every task traces back to the company mission. Agents don’t drift into busywork because the system enforces that all work connects to defined goals.

Hierarchy:

Company Mission: "Build the #1 AI note-taking app to $1M MRR"
└── Project: "Launch MVP in 3 months"
    ├── Task: "Design database schema"
    ├── Task: "Build REST API"
    ├── Task: "Create React frontend"
    └── Task: "Write marketing copy"

Each task knows the “why” — not just the “what”.

4. Heartbeat Scheduling

Agents check in at regular intervals, report status, and pick up new tasks. This creates a rhythm similar to daily standups in human teams.

Example heartbeats:

• CEO: Every 24 hours (review strategy, adjust priorities)

• Engineers: Every 4 hours (check tasks, commit code)

• Content Writer: Every 8 hours (publish posts, check analytics)

• DevOps: Every 1 hour (monitor systems, handle alerts)

5. Ticket System with Audit Trail

Every conversation is traced. Every decision is explained. Full tool-call tracing and an immutable audit log.

Sample audit log:

[2026-03-15 09:23:14] CEO Agent: Created project "Launch MVP"
[2026-03-15 09:23:45] CEO Agent: Assigned task "Design DB" to CTO
[2026-03-15 10:15:22] CTO Agent: Delegated to Senior Engineer
[2026-03-15 11:42:18] Senior Engineer: Completed schema design
[2026-03-15 11:42:19] Senior Engineer: Used 12,400 tokens ($0.18)
[2026-03-15 11:42:20] CTO Agent: Approved schema, moved to next task

6. Atomic Execution

Task checkout and budget enforcement are atomic, meaning no double-work and no runaway spend. If one agent starts a task, no other agent can work on it until it’s completed or released.

7. Persistent Agent State

Agents resume with the same task context across heartbeats instead of restarting from scratch. This is critical for long-running tasks.

8. Multi-Company Support

A single deployment can run multiple companies with full data isolation. Perfect for agencies or founders running multiple ventures.

Use case:

• Company A: SaaS startup (5 agents, $1,500/month budget)

• Company B: Content agency (8 agents, $800/month budget)

• Company C: E-commerce store (4 agents, $600/month budget)

All run on the same Paperclip instance, but data is fully isolated.

9. Governance with Rollback

Approval gates are enforced, config changes are versioned, and bad changes can be safely rolled back.

Example governance rules:

• All customer emails must be approved by the CEO

• All production deploys must be approved by the CTO

• All expenses over $50 must be approved by the CFO

• All org chart changes must be approved by the founder

Comparison: Paperclip vs OpenClaw — Complementary Tools

Understanding the Relationship

This isn’t a competition. Paperclip and OpenClaw solve different problems and are designed to work together.

When to Use Which?

Use OpenClaw when:

• You need an autonomous, proactive agent

• You want the agent to live in messaging apps

• You are a solo founder or small team (1–3 people)

• You need persistent memory and identity

• You want the agent to decide what to do

Use Paperclip when:

• You have 5+ agents to coordinate

• You need strict budget control

• You need governance and approval workflows

• You run multiple companies/projects

• You need a full audit trail

Use both when:

• You want OpenClaw agents to operate within a Paperclip org chart

• You need OpenClaw’s autonomy + Paperclip’s coordination

• You’re scaling from 1 agent to 10+ agents

Case Study: Felix — A $200K Company With No Employees

The Story

Nat Eliason, a writer and entrepreneur, created Felix — a “one-person company” with a goal of $1M in revenue using only AI agents. Built on the OpenClaw framework, Felix generated nearly $200,000 in the first few weeks of 2026.

Felix’s Structure

Revenue streams:

• PDF sales: Selling guides and tutorials about OpenClaw

• Claw Mart: Marketplace for OpenClaw skills

• Clawcommerce: Custom services — deploying OpenClaw for businesses

Agents inside Felix:

• Content Agent: Writes blog posts, tutorials, documentation

• Marketing Agent: Social media, email campaigns, SEO

• Sales Agent: Lead research, outreach, follow-ups

• Support Agent: Customer support via Discord and email

• Dev Agent: Maintain Claw Mart, fix bugs, add features

Results After 6 Weeks

• Revenue: ~$200,000 (on track to $1M)

• API costs: ~$800/month (mainly Claude and GPT-4)

• Nat’s time: 5–10 hours/week (mostly strategic decisions)

• Agents: 24/7 uptime

• Customers: 2,400+ (PDF + Claw Mart + services)

• Support tickets: 95% handled automatically by AI

Lessons From Felix

1. Mistakes compound faster with agents:

Felix once sent 23 emails instead of 3 due to a logic bug. Humans would notice after the second or third email. AI sent all 23 before anyone noticed. Budget controls and human checkpoints are mandatory.

2. ROI shows up in months 2–3, not week 1:

Setting up AI agent workflows takes time and iteration. The payoff comes after agents learn patterns and processes. Businesses expecting instant results will be disappointed.

3. Human oversight never disappears:

Even in a “zero-human company,” a human sets strategy, reviews outcomes, and makes judgment calls. The human role shifts from “doing the work” to “governing the system.”

Paperclip Setup Guide: From Zero to Company in 30 Minutes

Step 1: Quick Install (5 minutes)

Method 1: Automated onboarding (recommended):

npx paperclipai onboard --yes

This command will:

• Clone the repo from GitHub

• Install dependencies

• Create an embedded PostgreSQL database

• Start the API server at localhost:3100

• Open the dashboard UI in your browser

Method 2: Manual setup:

git clone https://github.com/paperclipai/paperclip.git
cd paperclip
pnpm install
pnpm dev

Requirements:

• Node.js 20+

• pnpm 9.15+

• 8GB RAM (16GB recommended)

• 5GB disk space

Step 2: Create Your First Company (10 minutes)

1. Open the dashboard:

http://localhost:3100

2. Create a company:

Company Name: "MyStartup"
Mission: "Build the #1 AI note-taking app to $1M MRR"
Monthly Budget: $2,000

3. Hire agents (build your org chart):

# CEO
Role: CEO
Agent Type: Claude Opus
Monthly Budget: $200
Responsibilities: Strategy, goal decomposition, priority setting

# CTO
Role: CTO
Agent Type: GPT-4
Reports To: CEO
Monthly Budget: $500
Responsibilities: Technical architecture, code review, DevOps

# Senior Engineer
Role: Senior Engineer
Agent Type: Claude Sonnet
Reports To: CTO
Monthly Budget: $400
Responsibilities: Feature development, API design, database

# Content Writer
Role: Content Writer
Agent Type: GPT-4
Reports To: CEO
Monthly Budget: $300
Responsibilities: Blog posts, documentation, marketing copy

Step 3: Configure API Keys (5 minutes)

In the dashboard, go to Settings → API Keys:

# Anthropic (for Claude agents)
ANTHROPIC_API_KEY=sk-ant-xxxxx

# OpenAI (for GPT agents)
OPENAI_API_KEY=sk-xxxxx

# Optional: Gemini, DeepSeek, Ollama
GOOGLE_API_KEY=xxxxx
DEEPSEEK_API_KEY=xxxxx

Step 4: Create Your First Project (10 minutes)

1. Create a project:

Project Name: "MVP Launch"
Goal: "Launch working note-taking app in 3 months"
Owner: CEO Agent
Budget: $1,500
Deadline: 2026-06-15

2. The CEO agent will automatically decompose into tasks:

After you create the project, the CEO agent analyzes and creates tasks:

• Design database schema (assign to CTO)

• Build REST API (assign to Senior Engineer)

• Create React frontend (assign to Senior Engineer)

• Write documentation (assign to Content Writer)

• Set up CI/CD (assign to CTO)

3. Approve and run:

Review the CEO’s strategy, approve it, and agents begin working on the heartbeat schedule.

Technical Architecture: How Paperclip Works

High-Level Architecture

┌─────────────────────────────────────────────┐
│         React Dashboard (Frontend)          │
│  - Org chart visualization                  │
│  - Task management                          │
│  - Budget monitoring                        │
│  - Approval workflows                       │
└─────────────────┬───────────────────────────┘
                  │ REST API
┌─────────────────▼───────────────────────────┐
│      Node.js Server (Orchestration)         │
│  - Task routing                             │
│  - Budget enforcement                       │
│  - Heartbeat scheduling                     │
│  - Audit logging                            │
└─────────────────┬───────────────────────────┘
                  │
        ┌─────────┴─────────┐
        │                   │
┌───────▼────────┐  ┌──────▼──────────┐
│   PostgreSQL   │  │  Agent Runtime  │
│   - Companies  │  │  - OpenClaw     │
│   - Agents     │  │  - Claude Code  │
│   - Tasks      │  │  - Codex        │
│   - Budgets    │  │  - Cursor       │
│   - Audit logs │  │  - HTTP agents  │
└────────────────┘  └─────────────────┘

Database Schema (Simplified)

-- Companies
CREATE TABLE companies (
  id UUID PRIMARY KEY,
  name TEXT NOT NULL,
  mission TEXT,
  monthly_budget DECIMAL,
  created_at TIMESTAMP
);

-- Agents
CREATE TABLE agents (
  id UUID PRIMARY KEY,
  company_id UUID REFERENCES companies(id),
  role TEXT NOT NULL,
  agent_type TEXT, -- 'claude-opus', 'gpt-4', etc.
  reports_to UUID REFERENCES agents(id),
  monthly_budget DECIMAL,
  current_spend DECIMAL DEFAULT 0,
  heartbeat_interval INTEGER, -- seconds
  last_heartbeat TIMESTAMP
);

-- Tasks
CREATE TABLE tasks (
  id UUID PRIMARY KEY,
  company_id UUID REFERENCES companies(id),
  project_id UUID REFERENCES projects(id),
  assigned_to UUID REFERENCES agents(id),
  title TEXT NOT NULL,
  status TEXT, -- 'pending', 'in_progress', 'completed'
  budget DECIMAL,
  spent DECIMAL DEFAULT 0,
  checked_out_by UUID REFERENCES agents(id),
  checked_out_at TIMESTAMP
);

-- Audit Log
CREATE TABLE audit_log (
  id UUID PRIMARY KEY,
  company_id UUID REFERENCES companies(id),
  agent_id UUID REFERENCES agents(id),
  action TEXT NOT NULL,
  details JSONB,
  tokens_used INTEGER,
  cost DECIMAL,
  timestamp TIMESTAMP
);

Heartbeat System

Paperclip uses a heartbeat pattern so agents act proactively:

// Pseudo-code of the heartbeat loop
async function heartbeat(agent) {
  while (true) {
    // 1. Check budget
    if (agent.currentSpend >= agent.monthlyBudget) {
      await sleep(agent.heartbeatInterval);
      continue;
    }

    // 2. Check for assigned tasks
    const tasks = await getAssignedTasks(agent.id);
    
    // 3. Checkout task (atomic)
    const task = await checkoutTask(tasks[0], agent.id);
    if (!task) {
      await sleep(agent.heartbeatInterval);
      continue;
    }

    // 4. Execute task
    const result = await agent.execute(task);
    
    // 5. Log to audit trail
    await logExecution(agent, task, result);
    
    // 6. Update budget
    await updateBudget(agent, result.cost);
    
    // 7. Mark task complete
    await completeTask(task.id, result);
    
    // 8. Sleep until next heartbeat
    await sleep(agent.heartbeatInterval);
  }
}

Atomic Task Checkout

To avoid double-work, Paperclip uses PostgreSQL row-level locking:

-- Atomic checkout
UPDATE tasks
SET 
  checked_out_by = $agent_id,
  checked_out_at = NOW(),
  status = 'in_progress'
WHERE id = $task_id
  AND checked_out_by IS NULL
RETURNING *;

If two agents try to check out a task, only one succeeds. The other gets NULL and moves on.

Clipmart: A Marketplace for “Company-in-a-Box”

Vision

Clipmart (in development) is a marketplace where you can download and run entire companies with one click. Browse prebuilt company templates — full org structures, agent configs, and skills — and import them into your Paperclip instance in seconds.

Example Templates

1. Content Agency Template:

• CEO (strategy, client management)

• Content Director (editorial calendar, quality control)

• 3x Writers (blog posts, social media, newsletters)

• SEO Specialist (keyword research, optimization)

• Designer (graphics, thumbnails)

• Budget: $800/month

• Output: 40 blog posts, 120 social posts, 8 newsletters/month

2. SaaS Startup Template:

• CEO (product vision, fundraising)

• CTO (architecture, code review)

• 2x Engineers (frontend, backend)

• DevOps (CI/CD, monitoring)

• Product Manager (roadmap, user research)

• Marketing Manager (growth, content)

• Budget: $2,500/month

• Output: MVP in 3 months

3. E-commerce Store Template:

• CEO (strategy, vendor relationships)

• Marketing Manager (ads, email campaigns)

• Content Creator (product descriptions, videos)

• Customer Support (tickets, refunds)

• Analyst (sales data, inventory)

• Budget: $600/month

• Output: 500+ product listings, 24/7 support

How Clipmart Works

# Browse templates
paperclip browse

# Preview template
paperclip preview content-agency

# Install template
paperclip install content-agency --company-name "MyAgency"

# Customize
paperclip config edit MyAgency

# Run
paperclip start MyAgency

Templates include:

• Full org chart with roles and reporting lines

• Agent configs (model, temperature, system prompts)

• Skills and tools per role

• Budget allocations

• Governance rules

• Sample projects and tasks

Real-World Case Studies: 3 Businesses Running on Paperclip

Case 1: Content Marketing Agency (Australia)

Background: A solo founder in Sydney wants to run a content agency without hiring a team.

Setup:

• 8 agents: CEO, Content Director, 4 Writers, SEO Specialist, Designer

• Budget: $950/month

• Clients: 6 SMEs (each paying $800–1,200/month)

Workflow:

1. CEO agent receives the client brief via email

2. Content Director builds the editorial calendar

3. Writers produce content based on the calendar

4. SEO Specialist optimizes for search

5. Designer creates featured images

6. CEO agent sends drafts for client approval

7. After approval, content is published automatically

Results after 2 months:

• Revenue: $6,400/month (6 clients × $1,067 average)

• AI costs: $950/month

• Other costs: $200/month (hosting, tools)

• Profit margin: 82% ($5,250 profit/month)

• Founder time: 8 hours/week (client calls, approvals)

• Output: 48 blog posts, 144 social posts, 12 newsletters/month

Case 2: SaaS Startup (Singapore)

Background: A technical founder wants to build a SaaS product without a co-founder.

Setup:

• 7 agents: CEO, CTO, 2 Engineers, DevOps, PM, Marketing

• Budget: $2,200/month

• Product: AI-powered project management tool

Timeline:

• Weeks 1–2: CEO and PM define requirements, CTO designs architecture

• Weeks 3–8: Engineers build the MVP (database, API, frontend)

• Weeks 9–10: DevOps sets up CI/CD and monitoring

• Weeks 11–12: Marketing creates the landing page, content, launch plan

Results after 3 months:

• MVP: Delivered on time

• AI costs: $6,600 total (3 months × $2,200)

• Code quality: 85% test coverage, zero critical bugs

• Early users: 120 signups in the first 2 weeks

• Founder time: 15 hours/week (product decisions, user interviews)

Compared to hiring a team:

• Human team cost: ~$180,000 (3 months × 3 engineers × $20K/month)

• Paperclip cost: $6,600

• Savings: 96.3%

Case 3: E-commerce Automation (Vietnam)

Background: A shop owner in Hanoi sells 300+ products on Shopify, spending 6–8 hours/day on customer support and content.

Setup:

• 5 agents: CEO, Marketing, Content Creator, Support, Analyst

• Budget: $580/month

• Integrations: Shopify API, Gmail, Facebook Messenger

Automated workflow:

• Content Creator: Writes product descriptions for 300 items in 2 days

• Marketing: Runs Facebook ads and automated email campaigns

• Support: Answers 90% of customer questions via Messenger

• Analyst: Daily reports on sales, inventory, and customer behavior

Results after 1 month:

• Owner’s time: Down from 8 hours/day to 2 hours/day

• Support response time: Down from 4 hours to 5 minutes

• Conversion rate: Up 18% thanks to better product descriptions

• Customer satisfaction: Up from 3.2/5 to 4.1/5

• Costs: $580/month (vs $1,200/month for a VA)

Budget Control: Why This Is the Most Important Feature

The Problem: Runaway AI Costs

Without budget controls, AI agents can burn through thousands of dollars in hours. These real scenarios have happened:

Scenario 1: Infinite loop bug:

Agent A: "Create 10 blog posts"
Agent A calls GPT-4: $0.50
Agent A isn’t satisfied with the output
Agent A retries: $0.50
Agent A still isn’t satisfied
Agent A retries 847 times
Cost: $423.50 in 2 hours

Scenario 2: Overzealous research:

Marketing Agent: "Research 100 competitors"
Agent calls web search API: 100 queries × $0.02 = $2
Agent analyzes each competitor with GPT-4: 100 × $0.80 = $80
Agent creates comparison report: $1.20
Not approved, redoes with 200 competitors
Cost: $164 in 1 day

Paperclip’s Solution

1. Hard budget limits:

Agent monthly budget: $300
Current spend: $285
Remaining: $15

Next task cost estimate: $25
→ Task rejected, agent paused until next month

2. Tiered warnings:

• 50% budget: Log a warning

• 80% budget: Email notification

• 90% budget: Require approval for every task

• 100% budget: Agent automatically pauses

3. Cost estimation before execution:

Task: "Write 5,000-word article"
Estimated tokens: ~8,000 (input) + ~7,000 (output)
Estimated cost: $0.24 (GPT-4o-mini)
Budget check: $15 remaining → OK
Execute: Approved

4. Circuit breakers:

If agent.consecutiveFailures > 3:
  pause agent
  notify human
  require manual review

Deployment Options: From Laptop to Production

Option 1: Local Development (Free)

Setup:

pnpm dev

Specs:

• Embedded PostgreSQL (no separate install required)

• Local file storage

• Accessible from localhost only

• Perfect for testing and development

Cost: $0 (you only pay for agent API calls)

Option 2: VPS Self-Hosted ($5–20/month)

Providers:

• DigitalOcean Droplet: $12/month (2GB RAM, 50GB SSD)

• Hetzner Cloud: €4.51/month (~$5, 4GB RAM, 40GB SSD)

• Vultr: $6/month (2GB RAM, 55GB SSD)

Setup:

# SSH into VPS
ssh root@your-vps-ip

# Install Node.js 20
curl -fsSL https://deb.nodesource.com/setup_20.x | bash -
apt-get install -y nodejs

# Install pnpm
npm install -g pnpm

# Clone and set up
git clone https://github.com/paperclipai/paperclip.git
cd paperclip
pnpm install

# Set up PostgreSQL
apt-get install -y postgresql
sudo -u postgres createdb paperclip

# Configure
cat > .env << EOF
DATABASE_URL=postgresql://postgres:password@localhost:5432/paperclip
PORT=3100
NODE_ENV=production
EOF

# Build and run
pnpm build
pnpm start

# Set up a systemd service
cat > /etc/systemd/system/paperclip.service << EOF
[Unit]
Description=Paperclip AI Orchestration
After=network.target postgresql.service

[Service]
Type=simple
User=root
WorkingDirectory=/root/paperclip
ExecStart=/usr/bin/pnpm start
Restart=always

[Install]
WantedBy=multi-user.target
EOF

systemctl enable paperclip
systemctl start paperclip

Remote access with Tailscale (recommended):

# Install Tailscale on the VPS
curl -fsSL https://tailscale.com/install.sh | sh
tailscale up

# Now access from anywhere via the Tailscale IP
http://100.x.x.x:3100

Option 3: Cloud Deployment (Vercel/Railway)

Vercel (recommended for production):

# Install Vercel CLI
npm i -g vercel

# Deploy
cd paperclip
vercel

# Set environment variables in the Vercel dashboard:
DATABASE_URL=postgresql://user:pass@host:5432/db
ANTHROPIC_API_KEY=sk-ant-xxxxx
OPENAI_API_KEY=sk-xxxxx

Vercel costs:

• Hobby: $0 (100GB bandwidth limit)

• Pro: $20/month (1TB bandwidth)

• Database: Use Supabase ($0–25/month) or Neon ($0–69/month)

Estimated Total Monthly Costs

Note: Your main cost is AI API calls, not hosting.

Paperclip + OpenClaw: The Perfect Combination

Why Use Both?

OpenClaw excels at autonomy, persistence, and human communication. Paperclip excels at task decomposition, agent coordination, and budget management. Combined, you get what neither tool achieves alone — an autonomous company with a single point of contact.

Pattern: “Agentic Company”

This pattern is used by many founders:

Human Founder
    ↓
OpenClaw Agent (CEO)
    ↓
Paperclip Orchestration
    ↓
├── CTO Agent (Claude)
├── Engineer Agents (GPT-4)
├── Marketing Agents (Claude)
└── Support Agents (GPT-4o-mini)

How it works:

1. The founder communicates with the OpenClaw CEO via Telegram: “I want to launch feature X in 2 weeks.”

2. The OpenClaw CEO creates a project in Paperclip: Decomposes into tasks, estimates budget, assigns agents

3. Paperclip orchestrates execution: CTO reviews architecture, Engineers code, DevOps deploy

4. The OpenClaw CEO reports progress to the founder: Daily updates via Telegram

5. The founder only approves major decisions: Architecture changes, budget increases, hiring

Integration Setup

# 1. Set up Paperclip
pnpm dev

# 2. Set up OpenClaw
git clone https://github.com/openclaw/openclaw.git
cd openclaw
pip install -e .

# 3. Configure OpenClaw to connect to Paperclip
cat > workspace/SKILLS/paperclip.py << EOF
import requests

class PaperclipSkill:
    def __init__(self):
        self.api_url = "http://localhost:3100/api"
        self.api_key = "your-paperclip-api-key"
    
    def create_project(self, name, goal, budget):
        response = requests.post(
            f"{self.api_url}/projects",
            headers={"Authorization": f"Bearer {self.api_key}"},
            json={"name": name, "goal": goal, "budget": budget}
        )
        return response.json()
    
    def get_tasks(self, project_id):
        response = requests.get(
            f"{self.api_url}/projects/{project_id}/tasks",
            headers={"Authorization": f"Bearer {self.api_key}"}
        )
        return response.json()
    
    def report_progress(self, project_id):
        tasks = self.get_tasks(project_id)
        completed = [t for t in tasks if t['status'] == 'completed']
        return f"{len(completed)}/{len(tasks)} tasks completed"
EOF

# 4. Add the skill to OpenClaw SOUL.md
echo "- Paperclip integration: Create projects, monitor tasks, report progress" >> workspace/SOUL.md

# 5. Run
openclaw run

Results

You can chat with the OpenClaw CEO via Telegram like a real person, and it will orchestrate the entire company inside Paperclip. Best of both worlds.

Limitations and Challenges

Technical Limitations

• High learning curve: Requires understanding organizational design, not just configuring a chatbot

• Complex setup: Many moving parts (Node.js, PostgreSQL, agents, API keys)

• Incomplete documentation: New project (early 2026), docs aren’t comprehensive yet

• Difficult debugging: Bugs are hard to trace across multiple agents

• Latency: The orchestration layer adds overhead; slower than direct agent calls

• Single point of failure: If the Paperclip server goes down, the whole company stops

Business Challenges

• Quality control: AI output is less consistent than human output; requires review processes

• Customer trust: Many customers are uncomfortable with “AI-only” companies

• Legal liability: If an AI agent causes harm, who is responsible?

• Compliance: Many industries (finance, healthcare) require human oversight

• Creativity limits: AI is strong at execution, weaker at breakthrough ideas

Ethical Concerns

• Job displacement: Zero-human companies threaten freelancer and agency work

• Race to the bottom: Service prices may drop sharply, making it hard for human workers

• Quality degradation: If everyone uses AI, content can become generic

• Accountability gap: Legal responsibility is unclear when AI makes mistakes

When Shouldn’t You Use Paperclip?

Misfit Scenarios

1. You just need a chatbot:

If your use case is “answer questions” or “produce simple content,” use ChatGPT or Claude directly. Paperclip is overkill.

2. You don’t have agents yet:

Paperclip orchestrates the agents you already have. If you have none, start with OpenClaw or Claude Code first.

3. Your work requires high creativity:

AI is great at execution, not yet at breakthrough creative work. If your business lives on creativity (design agency, advertising), AI should be an assistant, not the entire team.

4. Highly regulated industries:

Finance, healthcare, legal — these require human oversight and have AI regulations. A zero-human company is not a fit.

5. No technical background:

Paperclip requires setting up Node.js, PostgreSQL, configuring agents, and debugging. If you’re not comfortable with the terminal and code, it’s not for you (yet).

Roadmap: The Future of Paperclip

Q2 2026

• Clipmart launch: Marketplace for company templates

• Easier OpenClaw onboarding: One-click integration

• Cloud agents support: Cursor, e2b agents

• Better docs: Comprehensive guides and tutorials

Q3–Q4 2026

• Plugin system: Custom knowledge base, tracing, queues

• Better agent configs: Easier to understand and customize

• Harness engineering support: Advanced agent coordination patterns

• Mobile app: Native iOS/Android apps (currently only responsive web)

• Bring-your-own-ticket-system: Integrations with Asana, Trello, Linear

Long-Term Vision

According to the Paperclip team, the vision is:

"In five years, starting a company will feel like deploying an app. You pick a template, customize it, and hit deploy. Your company runs 24/7, generates revenue, and scales automatically. You only set strategy and approve major decisions."

Community and Ecosystem

GitHub Stats (2026-03-15)

• Stars: 12,800 (growing fast)

• Forks: 680

• Contributors: 34

• Open issues: 156

• Pull requests: 89

• Discord: 5,600+ members

Related Projects

1. Paperclip Templates (community-driven):

• github.com/paperclip-templates

• 45+ community-contributed company templates

• Content agencies, SaaS startups, e-commerce, consulting

2. Paperclip Plugins:

• Slack integration

• Notion sync

• Stripe billing automation

• Analytics dashboards

3. Paperclip CLI (paperclipper):

# Install
npm install -g paperclipper

# Commands
paperclipper init          # Create a new company
paperclipper hire          # Add an agent
paperclipper status        # View company status
paperclipper budget        # Check budget usage
paperclipper logs          # View audit logs

Comparison With Other Tools

Paperclip vs LangChain/AutoGen/CrewAI

Comparison Conclusion

LangChain, AutoGen, and CrewAI are frameworks to build agents. Paperclip is the platform to run companies made of agents. They aren’t competitors — they complement each other.

Typical stack:

LangChain/AutoGen → Build custom agents
OpenClaw → Autonomous agent runtime
Paperclip → Company orchestration layer

The “Zero-Human Company” Trend in 2026

Real Examples

1. Felix (Nat Eliason) — $200K in weeks:

• OpenClaw-based company

• 3 revenue streams: PDF sales, Claw Mart, Clawcommerce

• Target: $1M revenue

• Mentioned on the Bankless podcast (2026-03-04)

2. Aaron Sneed — 15 AI agents council:

• Profiled by Business Insider (02/2026)

• 15 custom GPT agents with specific roles

• Saves 20+ hours/week

• Agents coordinate like a management team

3. FelixCraft — $80K in 30 days:

• Platform to create and sell AI-generated products

• Fully automated from creation to fulfillment

• Mentioned in a Contrary Research report

4. Polcia — $1M ARR with 1,200+ sub-companies:

• Platform running thousands of automated micro-businesses

• Each “company” is a small niche business

• Aggregate revenue: $1M ARR

Market Stats

• Autonomous agents market: Projected 43% CAGR

• 82% of Global 2000 companies: Will have dedicated AI orchestration budget line items in 2026

• Enterprise AI budgets: Doubled vs 2024

• Top-quartile AI users: 6x output gap vs average users

• Anthropic engineers: 67% increase in merged PRs thanks to AI agents

Best Practices: How to Succeed With Paperclip

1. Start Small

Don’t create 20 agents on day one. Start with 2–3 agents for a specific workflow.

Example starter setup:

• CEO Agent: Strategy and coordination

• Worker Agent: Execution (content, code, research)

• QA Agent: Review and quality control

Run for 2–4 weeks, learn the patterns, then scale.

2. Map Processes Before You Automate

If you can’t explain the steps of a task, an AI agent can’t do it reliably.

Bad: “Do marketing”

Good:

1. Research 10 competitors

2. Identify 3 content gaps

3. Write 1 blog post addressing gap #1

4. Optimize for SEO (target keyword: X)

5. Create 5 social posts promoting the blog

6. Schedule posts for next week

3. Set Conservative Budgets Early

You can always increase budgets. It’s much harder to recover from an unexpected $2,000 bill.

Recommended starting budgets:

• CEO/strategic agents: $100–200/month

• Worker agents: $200–400/month

• QA/review agents: $50–100/month

• Total company: $500–1,000/month in the first month

4. Review Audit Logs Daily

At least for the first two weeks, check audit logs daily to catch issues early.

Red flags to watch:

• An agent retrying the same task many times

• Sudden spikes in token usage

• Tasks completed too quickly (possible low-quality output)

• Agents not completing tasks (possibly stuck)

5. Human Checkpoints for High-Stakes Decisions

Don’t let agents automate everything. Set approval gates for:

• Emails to clients/customers

• Production deploys

• Expenses above $50

• Pricing or terms changes

• Hiring/firing agents

Advanced Patterns: After You’ve Mastered the Basics

Pattern 1: Hierarchical Delegation

The CEO agent doesn’t assign tasks directly to engineers. The CEO assigns to the CTO, and the CTO assigns to engineers.

CEO: "Launch feature X"
  ↓
CTO: "Design architecture, estimate effort"
  ↓
Senior Engineer: "Implement backend"
Junior Engineer: "Implement frontend"
DevOps: "Set up deployment"

This scales better than a flat structure.

Pattern 2: Specialist Agents

Instead of one “Engineer” agent doing everything, create specialist agents:

• Backend Engineer: API, database, business logic

• Frontend Engineer: React, UI/UX, responsive design

• DevOps Engineer: CI/CD, monitoring, infrastructure

• QA Engineer: Testing, bug reports, quality assurance

Use models that match the task:

• Backend: Claude Sonnet (great for complex logic)

• Frontend: GPT-4 (great for UI code)

• DevOps: GPT-4o-mini (simple scripts, cheaper)

• QA: Claude Haiku (fast, inexpensive for testing)

Pattern 3: Budget Pooling

Instead of a hard limit per agent, create department budgets:

Engineering Department: $1,200/month
├── CTO: $300 allocated, $180 used
├── Senior Engineer: $400 allocated, $420 used (over)
└── Junior Engineer: $500 allocated, $280 used

Department total: $880/$1,200 used (73%)
→ The Senior Engineer can borrow from the Junior Engineer pool

More flexible, but requires careful monitoring.

Pattern 4: Approval Workflows

Create multi-level approvals for sensitive operations:

Task: "Send email campaign to 5,000 customers"
  ↓
Marketing Agent: Draft email
  ↓
Marketing Manager Agent: Review and approve
  ↓
CEO Agent: Final approval
  ↓
Execute: Send emails

Pattern 5: Fallback Chains

When an agent fails, escalate automatically:

Junior Engineer: Attempt task
  ↓ (if fails after 2 tries)
Senior Engineer: Attempt task
  ↓ (if fails after 2 tries)
CTO: Attempt task
  ↓ (if fails)
Notify human: Manual intervention needed

ROI Math: Is Paperclip Worth It?

Scenario: Content Agency

Option A: Human team

• 1 Content Director: $5,000/month

• 2 Writers: $3,000/month each

• 1 SEO Specialist: $3,500/month

• 1 Designer: $3,000/month

• Total: $17,500/month

• Output: 40 blog posts, 120 social posts/month

Option B: Paperclip + AI agents

• Hosting: $20/month (Vercel + Supabase)

• AI API: $800/month (8 agents × $100 average)

• Human oversight: $2,000/month (founder, 10 hours/week)

• Total: $2,820/month

• Output: 40 blog posts, 120 social posts/month (same)

ROI:

• Savings: $14,680/month ($176,160/year)

• Savings: 84%

• Payback period: Immediate (setup takes 1–2 days)

Scenario: SaaS Startup MVP

Option A: Hire a team

• 1 CTO: $12,000/month

• 2 Engineers: $8,000/month each

• 1 Designer: $6,000/month

• Total: $34,000/month × 3 months = $102,000

• Timeline: 3 months to MVP

Option B: Paperclip

• Hosting: $20/month

• AI API: $2,200/month

• Founder time: $0 (sweat equity)

• Total: $2,220/month × 3 months = $6,660

• Timeline: 3 months to MVP (similar)

ROI:

• Savings: $95,340

• Savings: 93.5%

• Trade-off: Code quality may need more review

When ROI Isn’t Great

• Tasks requiring deep expertise: AI can’t replace senior specialists

• High-stakes decisions: Legal, compliance, financial — need human judgment

• Creative breakthrough work: AI is better at execution than innovation

• Relationship-heavy work: Sales, partnerships — need human touch

Troubleshooting: Common Issues

Problem 1: Agents Do Nothing

Symptoms: Agents are assigned tasks but don’t execute.

Possible causes:

• Heartbeat interval is too long (agent hasn’t woken up)

• Budget is exhausted (agent is paused)

• Invalid API keys (agent can’t call the LLM)

• Task lacks clear instructions

Solutions:

# Check agent status
paperclip status --agent-id xxx

# Check budget
paperclip budget --agent-id xxx

# Check logs
paperclip logs --agent-id xxx --last 50

# Trigger a manual heartbeat
paperclip heartbeat --agent-id xxx --force

Problem 2: Runaway Costs

Symptoms: Budget rising abnormally fast.

Possible causes:

• Agent stuck in a retry loop

• Task too complex, requires many tokens

• Agent using an expensive model (GPT-4) for simple tasks

Solutions:

# Pause the agent immediately
paperclip pause --agent-id xxx

# Review audit logs
paperclip logs --agent-id xxx --filter "cost > 1.0"

# Adjust budget
paperclip budget set --agent-id xxx --monthly 200

# Switch to a cheaper model
paperclip config edit --agent-id xxx --model "gpt-4o-mini"

Problem 3: Poor Output Quality

Symptoms: Agents complete tasks but the output doesn’t meet quality standards.

Solutions:

• Improve prompts: Add examples, constraints, and quality criteria

• Add a review step: Create a QA agent to review output before approval

• Use better models: Upgrade from GPT-4o-mini to GPT-4 or Claude Sonnet

• Provide more context: Link to style guides, examples, documentation

Problem 4: Agent Conflicts

Symptoms: Two agents do the same work or work at cross-purposes.

Solutions:

• Clear role definitions: Each agent must have a defined scope

• Atomic task checkout: Ensure database locking works correctly

• Communication protocols: Agents should notify others when doing related work

The Future: From Experiment to Mainstream

Predictions for the Next 12 Months

Q2 2026:

• Clipmart launches with 100+ company templates

• 1,000+ companies running on Paperclip

• The first “unicorn” zero-human company (valuation $1B+)

Q3 2026:

• Major VCs begin funding zero-human companies

• First regulations for AI-operated businesses

• Paperclip Enterprise (SaaS, managed hosting)

Q4 2026:

• 10,000+ zero-human companies operating

• Aggregate revenue: $100M+

• Paperclip becomes the standard for AI orchestration

Long-Term Impact

For founders:

• Lower barrier to entry — start a company with $500 instead of $50,000

• Faster time to market — MVP in weeks instead of months

• Run multiple companies in parallel

For workers:

• Competition from AI agents on routine work

• Need to upskill toward strategic/creative work

• Freelance rates may drop due to AI competition

For the economy:

• More companies (easier to start)

• Higher productivity per capita

• Potential wealth concentration (founders with AI > workers)

• Rethinking employment and the social safety net

Overall Assessment

Pros

• True orchestration: No other tool offers org chart, budget control, and governance like Paperclip

• Open-source and self-hosted: Full control, no vendor lock-in, free

• Multi-company support: Run multiple businesses from one deployment

• Agent-agnostic: Use any agent (OpenClaw, Claude, GPT, custom)

• Production-ready: Atomic execution, persistent state, audit trails

• Mobile-friendly: Manage your company from your phone

• Cost-effective: Save 80–95% vs a human team

• Scalable: From 2 agents to 50+ agents

Cons

• High learning curve: Requires org design knowledge, not just chatbot config

• Complex setup: Node.js, PostgreSQL, agents, API keys

• Thin documentation: New project, docs not yet comprehensive

• Smaller community: 5,600 Discord members (vs 50,000+ for OpenClaw)

• Harder debugging: Multi-agent issues are tough to trace

• Overkill for solo use: If you need only 1 agent, use OpenClaw directly

• Clipmart not launched yet: You must set up everything from scratch

Score

Overall: 8.2/10

• Innovation: 9.5/10 — Breakthrough in AI orchestration

• Usability: 6.5/10 — Hard for beginners, good once familiar

• Features: 9.0/10 — Complete for running companies

• Documentation: 6.0/10 — Improving

• Community: 7.0/10 — Growing quickly

• Value for money: 10/10 — Open-source, 80–95% savings

Final Advice: How Should You Start?

Beginner Roadmap

Month 1: Learn OpenClaw

• Set up an OpenClaw agent

• Automate 1–2 simple workflows

• Learn how agents work: memory system, skills

• Cost: $50–100

Month 2: Scale to 3–5 agents

• Add specialized agents (content, research, support)

• Start encountering coordination challenges

• Track costs manually in a spreadsheet

• Cost: $200–400

Month 3: Add Paperclip

• Set up Paperclip locally

• Import existing agents into the org chart

• Set budgets and governance rules

• Monitor from the dashboard instead of a spreadsheet

• Cost: $400–800

Month 4+: Scale and optimize

• Add agents as needed

• Optimize budgets based on data

• Automate more workflows

• Consider multi-company if you have multiple ventures

Preflight Checklist

You’re ready for Paperclip if:

• You already have 3+ agents running

• You’re experiencing coordination problems

• You’re worried about runaway costs

• You’re comfortable with Node.js and PostgreSQL

• You have 1–2 days to set up and learn

• You need audit trails and governance

You’re not ready if:

• You’ve never used AI agents

• You only need a simple chatbot

• You don’t have a technical background

• You expect a plug-and-play solution

• You don’t have time to iterate and optimize

Conclusion: What Is the Future of the Company?

Paperclip is not just a tool — it’s a vision for the future of companies. A future where starting a business is like deploying an app. A future where the founder doesn’t spend 80% of their time managing people, but focuses on strategy and vision.

The Big Question

Are zero-human companies the future?

Probably not for every business. But certainly for a significant subset — those where:

• Execution matters more than creativity

• Processes can be documented

• Scale matters more than personalization

• Cost efficiency is a competitive advantage

These businesses will go AI-first or AI-only. And Paperclip is the tool to make it happen.

Lessons for Developers

1. Orchestration > Individual capability:

A team of five average agents with strong coordination beats one brilliant agent working alone. That’s why Paperclip matters.

2. Governance isn’t overhead:

Budget controls, approval gates, and audit trails aren’t bureaucracy. They are the necessary infrastructure to scale safely.

3. Start simple, scale gradually:

Don’t build a 20-agent company on day one. Start with 2–3 agents, prove the model, then scale.

4. Human oversight is always needed:

Even in a “zero-human company,” the human founder is still the board of directors. AI executes, humans set strategy.

Final Advice

If you’re considering Paperclip:

1. Start with OpenClaw: Learn how a single agent operates first

2. Identify one specific workflow: Don’t try to automate everything at once

3. Set up Paperclip locally: Test with 2–3 agents for 2 weeks

4. Measure ROI: Track time saved, cost, and output quality

5. Scale if it works: Add agents, deploy to production, automate more

A zero-human company isn’t for everyone. But if you’re a technical founder, comfortable with AI, and want to build fast with a minimal team — this can be a game-changer.

The most important thing: Don’t be afraid to experiment. Paperclip is open-source and free. Worst case, you learn a lot about AI orchestration. Best case, you build a company that generates revenue 24/7 without hiring anyone.

The future of companies may not be zero-human — but it will be AI-augmented. Paperclip is how you start.

Bonus: Real-World Code Examples

Example 1: Create a Company via API

// create-company.js
const axios = require('axios');

async function createCompany() {
  // 1. Create company
  const company = await axios.post('http://localhost:3100/api/companies', {
    name: 'MyStartup',
    mission: 'Build the #1 AI note-taking app to $1M MRR',
    monthlyBudget: 2000
  });

  const companyId = company.data.id;

  // 2. Hire CEO
  const ceo = await axios.post('http://localhost:3100/api/agents', {
    companyId,
    role: 'CEO',
    agentType: 'claude-opus-4',
    monthlyBudget: 200,
    heartbeatInterval: 86400, // 24 hours
    systemPrompt: 'You are the CEO. Focus on strategy, goal decomposition, and priority setting.'
  });

  // 3. Hire CTO (reports to CEO)
  const cto = await axios.post('http://localhost:3100/api/agents', {
    companyId,
    role: 'CTO',
    agentType: 'gpt-4',
    reportsTo: ceo.data.id,
    monthlyBudget: 500,
    heartbeatInterval: 14400, // 4 hours
    systemPrompt: 'You are the CTO. Handle technical architecture, code review, and DevOps.'
  });

  // 4. Create project
  const project = await axios.post('http://localhost:3100/api/projects', {
    companyId,
    name: 'MVP Launch',
    goal: 'Launch working note-taking app in 3 months',
    ownerId: ceo.data.id,
    budget: 1500,
    deadline: '2026-06-15'
  });

  console.log('Company created:', companyId);
  console.log('Project created:', project.data.id);
}

createCompany();

Example 2: Monitor Budget Usage

// monitor-budget.js
const axios = require('axios');

async function monitorBudget(companyId) {
  const response = await axios.get(
    `http://localhost:3100/api/companies/${companyId}/budget`
  );

  const { agents, total } = response.data;

  console.log(`Company Budget: $${total.spent}/$${total.limit}`);
  console.log(`Remaining: $${total.limit - total.spent}\n`);

  agents.forEach(agent => {
    const percentage = (agent.spent / agent.budget * 100).toFixed(1);
    const status = percentage > 90 ? '[CRITICAL]' : percentage > 80 ? '[WARN]' : '[OK]';
    
    console.log(`${status} ${agent.role}: $${agent.spent}/$${agent.budget} (${percentage}%)`);
  });

  // Alert if any agent is near the budget limit
  const criticalAgents = agents.filter(a => a.spent / a.budget > 0.9);
  if (criticalAgents.length > 0) {
    console.log('\nWARNING: These agents are near the budget limit:');
    criticalAgents.forEach(a => {
      console.log(`  - ${a.role}: ${(a.budget - a.spent).toFixed(2)} remaining`);
    });
  }
}

// Run every hour
setInterval(() => monitorBudget('company-id-here'), 3600000);

Example 3: Custom Agent Integration

// custom-agent.js
// Create a custom agent that integrates with Paperclip

class CustomAgent {
  constructor(config) {
    this.id = config.id;
    this.role = config.role;
    this.paperclipUrl = config.paperclipUrl;
    this.apiKey = config.apiKey;
  }

  async heartbeat() {
    // 1. Get assigned tasks
    const tasks = await this.getTasks();
    
    if (tasks.length === 0) {
      console.log('No tasks assigned');
      return;
    }

    // 2. Check out the first task
    const task = await this.checkoutTask(tasks[0].id);
    
    if (!task) {
      console.log('Task already checked out by another agent');
      return;
    }

    // 3. Execute task
    const result = await this.executeTask(task);

    // 4. Report result
    await this.completeTask(task.id, result);
  }

  async getTasks() {
    const response = await axios.get(
      `${this.paperclipUrl}/api/agents/${this.id}/tasks`,
      { headers: { Authorization: `Bearer ${this.apiKey}` } }
    );
    return response.data;
  }

  async checkoutTask(taskId) {
    try {
      const response = await axios.post(
        `${this.paperclipUrl}/api/tasks/${taskId}/checkout`,
        { agentId: this.id },
        { headers: { Authorization: `Bearer ${this.apiKey}` } }
      );
      return response.data;
    } catch (error) {
      return null; // Already checked out
    }
  }

  async executeTask(task) {
    // Your custom logic here
    console.log(`Executing: ${task.title}`);
    
    // Call your LLM, run your code, etc.
    const output = await yourCustomLogic(task);
    
    return {
      status: 'completed',
      output: output,
      tokensUsed: 1200,
      cost: 0.024
    };
  }

  async completeTask(taskId, result) {
    await axios.post(
      `${this.paperclipUrl}/api/tasks/${taskId}/complete`,
      result,
      { headers: { Authorization: `Bearer ${this.apiKey}` } }
    );
  }

  start(intervalSeconds = 3600) {
    console.log(`Agent ${this.role} started with ${intervalSeconds}s heartbeat`);
    setInterval(() => this.heartbeat(), intervalSeconds * 1000);
  }
}

// Usage
const agent = new CustomAgent({
  id: 'agent-123',
  role: 'Content Writer',
  paperclipUrl: 'http://localhost:3100',
  apiKey: 'your-api-key'
});

agent.start(3600); // Heartbeat every hour

Appendix: Decision Tree — Which Tool Should You Use?

Selection Flowchart

Do you need AI for your business?
│
├─ Yes → How many agents?
│       │
│       ├─ 1 agent → Use OpenClaw or Claude Code directly
│       │
│       ├─ 2–4 agents → OpenClaw + manual coordination
│       │               (Paperclip not needed yet)
│       │
│       └─ 5+ agents → Do you need budget control?
│                      │
│                      ├─ Yes → Paperclip (required)
│                      │
│                      └─ No → Do you have $10K+ to burn?
│                                 │
│                                 ├─ Yes → Run without Paperclip
│                                 │        (prepare for surprises)
│                                 │
│                                 └─ No → Use Paperclip
│
└─ No → Why are you reading this?

Detailed Decision Table

Conclusion: Paperclip and the Zero-Human Revolution

Paperclip represents a fundamental shift in how we think about companies — from “organizations of people” to “organizations of agents.” From “managing employees” to “governing systems.”

This isn’t a distant future. It’s happening now. Felix is making $200K. Aaron Sneed is saving 20 hours/week. Hundreds of founders are experimenting with zero-human models.

The question isn’t “Will zero-human companies work?” — the answer is already yes, for the right use cases.

The real question is: “Is your business one of those use cases?”

If your business:

• Has processes that can be documented

• Values execution over creativity

• Benefits more from scale than personalization

• Relies on cost efficiency

Then the answer might be yes. And Paperclip is the tool to try.

If you’re unsure, start small. Set up an OpenClaw agent. Automate one workflow. Measure ROI. Then decide whether to scale into Paperclip.

The future of the company is being written now. And you can be part of it.