Paperclip

Paperclip is an open-source platform for orchestrating teams of AI agents that run businesses. Handler is the perfect governance layer — giving each Paperclip agent governed access to the real world.

What is Paperclip?

Paperclip is an open-source multi-agent orchestration platform built with Node.js, React, and Postgres. It coordinates dozens of AI agents in org-chart structures with budgets, goals, and approval gates. Key features:

Org-chart hierarchy. Agents are organized like employees — CEO, department heads, individual contributors — each with defined roles and reporting lines.
Multi-provider. Each agent can use a different LLM provider (Claude, GPT, Gemini, etc.).
Budget management. Built-in budget tracking and approval gates for spending control.
Goal-driven. Agents receive goals from their manager agents and report back with results.

Why Handler + Paperclip?

Paperclip coordinates what agents do. Handler governs how agents interact with external services. Together they form a complete stack:

Paperclip assigns tasks to agents based on org structure and goals
Handler governs each agent's access to external services with independent rules
Each agent gets its own sk-hndlr key with independent governance rules
Approval gates in Paperclip align naturally with Handler's hold-for-approval flow

Independent governance per agent. The sales agent can have different spending limits than the dev agent. Outbound emails can require approval while research calls auto-execute. Each agent's Handler key carries its own rules.

Setup

Each Paperclip agent connects to Handler independently. This means you configure Handler per-role, not per-org:

Create an agent in Handler for each Paperclip role

In your Handler dashboard, create a separate agent for each role in your Paperclip org (CEO, Sales, Dev, Marketing, etc.). Each gets its own sk-hndlr key.

Set governance rules per agent

Configure governance rules that match each role's responsibilities. A research agent gets liberal access; a sales agent gets restricted send access with approval requirements.

Configure each Paperclip agent's MCP connection

In your Paperclip configuration, set each agent's MCP connection to Handler with its own key:

{
  "mcpServers": {
    "handler": {
      "url": "https://mcp.usehandler.dev/mcp",
      "headers": {
        "Authorization": "Bearer sk-hndlr-AGENT_KEY"
      }
    }
  }
}

Replace sk-hndlr-AGENT_KEY with the specific key for that role.

Example: AI-Run Startup

Here is a Paperclip org with 4 Handler-governed agents. Each has distinct superpowers and governance rules tuned to its role.

CEO Agent

auto_approve: $10 monthly_cap: $200

Coordinates strategy, approves big decisions
Uses handler_research, handler_intel, handler_finance
Broad access with a generous cap for strategic research

Sales Agent

auto_approve: $2 (reads) notify_above: $0 (sends) monthly_cap: $50

Finds leads, sends outreach emails
Uses handler_intel, handler_communicate (gmail_send)
All outbound emails held for human approval — reads auto-execute

Dev Agent

auto_approve: $5 (reads) notify_above: $0 (writes) monthly_cap: $75

Manages GitHub issues, creates PRs
Uses handler_dev (gh_list_issues, gh_create_pr), handler_research
PR creation held for approval; issue listing auto-approved

Marketing Agent

auto_approve: $3 monthly_cap: $40

Monitors competitors, analyzes SEO, generates content
Uses handler_monitor, handler_marketing, handler_generate
Content generation auto-approved up to $3/call

Tip: Start with tight governance rules and loosen them as you build trust in each agent's behavior. It's easier to expand access than to undo an unintended action.

Obstacles

None. Paperclip agents are standard MCP clients. They connect to Handler exactly like Claude Code or Cursor. Each agent gets independent governance through its own sk-hndlr key. Paperclip's open-source architecture (MIT license) means you can customize the integration however you need.

Getting Started

Paperclip is open-source on GitHub: github.com/paperclipai/paperclip
Clone the repo, set up your org chart, and add Handler MCP config per agent
Each agent in the org chart maps to a Handler agent with its own key and governance rules
Use Paperclip's built-in budget tracking alongside Handler's spending caps for layered financial control

Two layers of control. Paperclip manages task assignment and internal budgets. Handler manages external service access and spending governance. Together, you have full visibility and control over your AI workforce.