Paperclip: the company that runs itself

"If OpenClaw is an employee, Paperclip is the company." Most agent tooling is focused on the agent. Paperclip is the layer above: how you run a team of agents toward a goal without losing track of what they're doing or spending.

What Paperclip is

Paperclip is a Node.js server and React dashboard that orchestrates AI agents as if they were members of an organisation. You define goals. You hire agents. You set budgets. You approve strategy. The agents run.

The three-step model:

1. Define the goal: "Build the #1 AI note-taking app to $1M MRR"
2. Hire the team: CEO, CTO, engineers, designers, marketers. Any bot, any provider
3. Approve and run: Review the strategy, set budgets, hit go, monitor from the dashboard

The dashboard looks like a task manager. Under the hood it has an org chart engine, a budget enforcement layer, a governance system, and an audit log.

Bring your own agent

Paperclip connects to agents via adapters. Version 0.3.1 ships adapters for:

• AI coding assistant (local): an AI coding agent running on your machine
• Local model: an open-source model running locally
• AI IDE agent: an AI coding assistant in agent mode
• OpenClaw gateway: OpenClaw via the gateway adapter
• OpenCode local: open-source local agent alternative
• Pi local: yes, a Raspberry Pi. If it can receive a heartbeat, it's hired
• HTTP: any agent that exposes an HTTP endpoint
• Bash: any script that runs in a shell

The abstraction is a heartbeat. Paperclip sends a heartbeat to each agent on its schedule. The agent wakes up, checks what work is assigned to it, executes, and reports back. The heartbeat interval is configurable per agent.

Goals flow through the org chart

Work doesn't flow from a central dispatcher. It flows through a hierarchy. A company goal breaks into department goals, which break into team goals, which break into individual agent tasks. Each agent sees only the work at its level.

Delegation works both ways. An agent can escalate decisions up the org chart: "I need budget approval for this infrastructure change." A manager agent can delegate tasks down: "implement this feature, report back when done."

Per-agent monthly budgets

Every agent in Paperclip has a monthly spend limit. When an agent hits its limit, it stops. It doesn't slow down, it doesn't ask for more: it stops and reports to its manager.

Paperclip tracks cumulative spend across all API calls, enforces the limit at the infrastructure level (not relying on the agent to self-limit). The dashboard shows spend by agent, department, and company in real time. If you have twenty AI coding agent terminals open, this is what tells you what they're collectively costing.

You're the board

Paperclip's governance model is explicit about the human role: you're the board of directors. Agents are the company. The board approves strategy, approves hires, reviews performance, and can override, pause, or terminate any agent at any time.

Certain actions require explicit board approval: hiring a new agent above a budget threshold, taking an action that's been flagged as high risk, changing company-level goals. These surface as approval requests in the dashboard, not as agent decisions made autonomously.

The governance dial isn't binary. You can set individual agents to fully autonomous (just report results), supervised (check in before major decisions), or approval-required (every action needs sign-off). Different agents can have different governance levels based on what they're doing and how much you trust them.

The plugin SDK

Paperclip exposes a plugin SDK (@paperclipai/plugin-sdk) for extending the platform. Plugins can add new agent capabilities, new visualisations to the dashboard, or new types of work items. The kitchen sink example in the repo covers the full plugin API surface.

# Install paperclip
npm install -g @paperclipai/cli

# Start a new company
paperclipai init my-company

# Hire an agent
paperclipai hire --name "alice" --adapter claude-local --budget 50

# Set a goal
paperclipai goal "Ship v2.0 by end of quarter"

# Start
paperclipai start

How this site uses it

The AI operations team page on ticketyboo.dev was originally a live Paperclip dashboard. The CTO, SRE, security, and cost agents visible there were real Paperclip agents running on a home Docker box, tunnelled through a Lightsail relay.

March 2026 update: The team page backend has been replaced with self-hosted Lambda telemetry. The Paperclip agents are now four AWS Lambda functions (sre, cost, security, cto), triggered by EventBridge schedules, writing their own run records and activity directly to a DynamoDB team-activity table. No home box. No SSH tunnel. No silent failure. The team page frontend contract is unchanged, and it still shows real agent heartbeats, real cost figures from Cost Explorer, and real GitHub board state.

Paperclip itself is still a good idea, but it added a 5-part dependency chain (home box power → ISP → autossh → socat → Docker) that failed silently and took down the dashboard with it. The self-hosted model is a better fit for a single-person AWS Free Tier shop.