Paperclip: Open‑Source Orchestration For Zero‑Human Companies

Key Takeaways: Paperclip is an open-source, self-hosted orchestration layer that turns your AI agents into a structured, autonomous company you control end-to-end.

AI agents are getting powerful, but coordinating them like a real company is still painful: scattered scripts, one-off workflows, and no clear ownership. Paperclip tackles this by giving your agents an org chart, goals, budgets, and governance so they can operate like a virtual company instead of a pile of bots.

In this guide, you’ll learn what Paperclip is, how it works under the hood, and how to install and self-host it (including running it with Docker) so you can start building your own “zero-human” company.

What Is Paperclip?

Paperclip is an open-source Node.js server with a React-based web UI that orchestrates a team of AI agents to run a business. Instead of talking to individual agents one by one, you manage a whole virtual company: org charts, roles, budgets, ticket queues, and audit logs.

It is designed as an orchestration layer rather than yet another chatbot: you “hire” agents from tools like OpenClaw, Claude Code, Cursor or your own runtimes, plug them into an org structure, and Paperclip handles scheduling, coordination, and governance.

Why Paperclip Matters For AI‑First Teams

Most agent setups today are fragile: YAML configs, cron jobs, and manual supervision that don’t scale beyond a few workflows. Paperclip brings production-style structure to this chaos with:

• Company-level goals and per-role responsibilities, so agents know not just what to do but why.
• Budgets and cost controls, so runaway loops and surprise bills get throttled instead of silently burning tokens.
• Governance and approvals, so humans stay in the loop for strategy and risky changes while agents handle execution.

For solo founders and small teams, this means you can act as “the board” while a virtual company of AI agents runs content, operations, support, or trading workflows on your behalf.

Core Concepts And Architecture

Paperclip exposes a few core building blocks that map directly to how real companies operate.

Org charts, roles, and goals

Paperclip lets you define full org charts: CEO, VPs, IC agents, and supporting roles, each with a title, responsibilities, and reporting lines. Every task, or “ticket,” is linked to a goal that traces back to the company mission, giving agents the necessary context for decisions instead of just short prompts.
This structure makes it natural to implement patterns like a strategy-setting CEO agent, execution-focused specialist agents (e.g., SEO, ads, support), and oversight roles that review work before it goes live.

Heartbeats, tickets, and governance

Agents in Paperclip wake up on a schedule via “heartbeats,” check ticket queues, perform work, then log decisions and tool calls. Tickets represent units of work with an owner, status, and conversation thread, creating a traceable history for every interaction.

On top of this, Paperclip adds a governance layer: you can approve strategies, approve or pause hires, override decisions, and roll back bad config changes while keeping an immutable audit log.

Multi‑company, open‑source, self‑hosted

One deployment of Paperclip can run many AI companies with strict data isolation, which is useful if you manage multiple ventures or want to template org structures. The project is MIT-licensed, open source, and built to be self-hosted with an interactive setup that walks you through database, auth, and your first company.

You can run it locally using a single Node.js process and an embedded Postgres, or deploy it remotely on your own infrastructure when you’re ready to scale.

Quickstart: Install Paperclip Locally With NPX

The easiest way to experience Paperclip is via its one-command onboarding flow.

Prerequisites

Before you start, make sure you have:

• A recent Node.js and npm installation on your machine.
• Network access to your preferred LLM/agent runtime APIs (e.g., OpenClaw, Claude, or your own tools).

The official quickstart emphasizes that you don’t need a Paperclip account; everything is configured locally.

Run the onboarding command

Open a terminal and run:

npx paperclipai onboard --yes

This command triggers the interactive setup wizard described in the official site and third-party overviews. Paperclip will:

• Launch a local Node.js server and embedded database (or connect to Postgres if you choose).
• Open a browser window pointing to the Paperclip UI.
• Walk you through creating your first company and AI CEO.

You can also run the command without --yes to step through prompts manually if you want finer control over the configuration.

Optional: Running Paperclip In Docker

If you prefer fully containerized deployments, the Paperclip repository includes a Dockerfile so you can build an image and run it as a containerized service.

A typical self-hosted Docker workflow looks like:

1. Clone the repository from GitHub:

git clone https://github.com/paperclipai/paperclip.git
cd paperclip

2. Build a Docker image using the provided Dockerfile:

docker build -t paperclipai/paperclip .

3. Run the container, exposing the web UI on a port of your choice and attaching storage for database and logs.

The project is designed to be adaptable to “any deployment target,” so you can wire this up to your existing Docker, Kubernetes, or PaaS stack as long as the container has access to your LLM providers and any external tools your agents need.

For production, combine Docker with:

• Managed Postgres instead of embedded storage.
• Externalized configuration for API keys and secrets.
• Reverse proxy (Nginx, Traefik, or a cloud load balancer) in front of the Paperclip service.

Onboarding: Creating Your First AI Company

Once onboarding completes, Paperclip opens a guided setup to create your first AI company and CEO agent.

You’ll walk through steps like:

• Naming your company and defining its mission, which later flows down into goals and tickets.
• Creating an AI CEO agent that owns strategy and high-level decision-making.
• Choosing which agent runtimes you want to connect first (e.g., coding agents, content agents, or custom APIs).

From there, you can use the visual org chart builder to add VPs and specialist roles (marketing, content, growth, trading, support, etc.) and assign them responsibilities and budgets.

Connecting Your Own AI Agents

Paperclip follows a “bring your own agent” philosophy: if an agent runtime can receive a heartbeat (ping) and respond, it can be plugged into the org chart.

Common patterns highlighted in early writeups include:

• Coding agents like Claude Code, Cursor, or other local dev copilots for engineering tasks.
• Workflow agents like OpenClaw that execute complex, multi-step jobs using tools and APIs.
• Domain-specific agents (SEO, ads, trading, support) built on top of your own tools and data.

Each agent is defined with:

• A role and title in the org chart.
• A set of skills or tools it can use.
• A budget and cost-tracking configuration.

Paperclip then uses heartbeats and ticket queues to wake agents, assign work, and log results while respecting these constraints.

Operating Your Zero‑Human Company Day To Day

Once your org is in place, you move from configuration to operations—treating Paperclip as your control plane for autonomous workflows.

Key operational workflows include:

• Goal-driven ticketing: You create or import goals (e.g., “grow MRR by X,” “publish 20 SEO articles per month”), then create tickets linked to those goals so agents can prioritize appropriately.
• Scheduled work via heartbeats: Recurring jobs like reporting, social posts, monitoring, or daily trading can be triggered by heartbeats instead of manual prompts.
• Cost and budget enforcement: Token usage is tracked per agent and per goal, with budget enforcement to stop runaway loops before they blow up your bill.
• Governance and overrides: As the “board,” you approve hiring new agents, review proposed strategies from your AI CEO, pause agents, or roll back configuration changes when needed.

Because every ticket, decision, and tool call is logged with full tracing and an immutable audit log, you can always see why something happened—crucial for debugging and compliance in production systems.

GEO & SEO Tips: Making Paperclip Work With Generative Engines

Since you’re likely reading this to build serious agent systems, it’s worth thinking about Generative Engine Optimization (GEO) alongside traditional SEO.

When you document and structure your Paperclip deployment:

• Use natural, descriptive role names and goal descriptions (e.g., “AI VP of Growth for B2B SaaS” instead of just “growth-agent”) so LLMs have rich context when summarizing your setup.
• Keep ticket titles and descriptions explicit about intent and constraints, which helps both models and humans reason about your workflows.
• Maintain a SKILL.md or similar documentation (Paperclip ships one for agent assistance) so agents helping you manage Paperclip understand how your org, agents, and tools fit together.

For search engines, target phrases like “open-source AI agent orchestration,” “self-hosted zero-human company,” and “AI org chart automation” throughout your internal docs and landing pages so human users can discover your Paperclip-powered products more easily.

FAQ: Common Questions About Paperclip

Is Paperclip really open-source and self-hosted?

Yes. Paperclip is MIT-licensed, open source, and intended to be self-hosted, with an interactive setup that configures database, auth, and your first company locally—no Paperclip SaaS account required.

Can I run multiple companies from one install?

Yes. A single deployment can host dozens of isolated companies with separate data and audit trails, which is ideal for agencies, studios, or founders running multiple ventures.

Where is the repository and documentation?

The main repository lives at https://github.com/paperclipai/paperclip, and the marketing/docs site at paperclip.ing provides the quickstart command and conceptual documentation.

Next Steps

If you want to turn your messy collection of agents and scripts into a coherent, observable, and governable AI company, your next move is straightforward:

1. Run npx paperclipai onboard --yes locally and let the wizard create your first AI CEO and company.
2. Map your real-world workflows (content, support, trading, ops) into Paperclip goals, tickets, and roles.
3. Gradually connect your existing agents and tools, then harden the deployment with Docker, Postgres, and your preferred cloud stack.

From there, you can focus on vision and strategy while your Paperclip-powered AI workforce handles the day-to-day execution.