Deploy paperclip

Paperclip

Paperclip is an open-source control plane for managing teams of AI agents. It provides a central interface for defining goals, organizing agents, assigning work, monitoring execution, controlling budgets, and auditing agent activity.

Paperclip runs as a self-hosted Node.js server with a React web interface. It is designed to work with different agent runtimes and providers, including coding agents and HTTP-based agents, so teams can coordinate multiple autonomous workers from a single workspace.

Deploy and Host

Paperclip can be deployed locally or self-hosted on your own infrastructure.

Local deployment

The fastest option is to run Paperclip on a local machine:

npx --registry https://registry.npmjs.org paperclipai onboard --yes

For development from source:

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

The development server runs on port 3100, with an embedded PostgreSQL database created automatically.

Docker deployment

Paperclip also provides a Docker Compose quickstart:

docker compose -f docker/docker-compose.quickstart.yml up --build

The default application port is 3100, and persistent application data is stored under ./data/docker-paperclip.

Self-hosted server

For a persistent deployment, Paperclip can run on a VPS or cloud server such as AWS, GCP, DigitalOcean, or Hetzner.

Internet-facing deployments should use authenticated mode with public exposure and a configured public base URL. Paperclip also supports authenticated private deployments for environments such as LANs, VPNs, and Tailscale networks.

About Hosting

Paperclip is self-hosted software. Your Paperclip instance runs on infrastructure that you control rather than requiring a Paperclip-hosted SaaS account.

A deployment stores its configuration, database, application storage, logs, and secrets on the host. The default local instance stores these under the Paperclip data directory, including the database, uploaded assets, storage, and secret key files.

For production deployments, you are responsible for the underlying server, networking, domain, TLS termination, backups, updates, and infrastructure security.

Paperclip supports three primary deployment configurations:

Why Deploy

Deploy Paperclip when you need a persistent control plane for AI agents rather than running agents independently from individual terminals.

A self-hosted Paperclip instance can provide:

• A central dashboard for multiple AI agents
• Organizational structures, roles, and reporting relationships
• Goal and task management
• Agent heartbeats and autonomous work scheduling
• Human approval and governance workflows
• Per-agent budgets and cost controls
• Agent activity and tool-call tracing
• Auditable work history
• Integration with different agent runtimes
• Persistent data and configuration
• Remote access for teams when deployed on a private or public server

Paperclip is particularly useful when multiple agents need to collaborate toward shared organizational goals while humans retain visibility and control over their work.

Common Use Cases

AI agent orchestration — Manage multiple AI agents from a shared control plane. Software development — Coordinate coding agents across projects, tasks, and repositories. Autonomous workflows — Run agents on recurring heartbeats and scheduled work. Multi-agent organizations — Define teams, roles, reporting relationships, goals, and responsibilities. Agent monitoring — Track agent activity, task progress, execution, and costs. Human-in-the-loop workflows — Review tasks and actions that require human approval. Self-hosted AI operations — Run the control plane on your own machine, server, VPS, or private network.

Autonomous AI teams

Create an organization of AI agents with roles such as CEO, CTO, engineers, designers, researchers, and marketers. Agents can be assigned responsibilities and coordinated through an organizational hierarchy.

Multi-agent software development

Coordinate coding agents such as Claude Code, Codex, Cursor, and other compatible runtimes from a shared control plane.

Long-running agent workflows

Use heartbeats and scheduled execution to allow agents to periodically wake up, inspect their work, and take action without requiring a human to manually start every task.

AI business operations

Use goals, tasks, budgets, approvals, and organizational structure to manage agents working on an autonomous or semi-autonomous business.

Agent governance

Use approval workflows, role boundaries, scoped secrets, audit trails, and budget controls to keep humans involved in important decisions.

Centralized agent monitoring

Deploy Paperclip on a server so a team can monitor agent activity and manage work from a shared web interface rather than individual local terminals.

Dependencies for

Paperclip requires:

• Node.js 24.11 or newer
• pnpm 9+ for development/source installations
• Docker for the Docker deployment option
• A persistent filesystem for application data
• A database; local installations can use Paperclip's embedded PostgreSQL setup
• A supported AI agent/runtime to perform work

The source repository currently documents Node.js 24.11+ and pnpm 9+ as development prerequisites.

For Docker deployments, Node.js and pnpm do not need to be installed on the host because the application runs inside the container.

Agent Compatibility

Paperclip is designed around a bring-your-own-agent model. The repository documents compatibility with agent runtimes including OpenClaw, Claude Code, Codex, Cursor, Bash-based agents, and HTTP agents.

This allows the Paperclip control plane to coordinate agents across different models, providers, and execution environments instead of requiring every agent to use the same underlying model.

Data Persistence

Paperclip persists application data on the deployment host.

A local instance can store:

• Configuration
• Database data
• Logs
• Uploaded assets
• Agent workspace data
• Application storage
• Secret material

For Docker deployments, the recommended bind mount keeps persistent data outside the container so it survives container recreation.

Security Considerations

For local experimentation, Paperclip can run in trusted local mode without a login flow.

For shared or internet-facing deployments, use authenticated deployment modes and configure the appropriate hostname and public base URL. Public deployments should also be protected with HTTPS and standard server-level security controls.

Do not expose a trusted local deployment directly to the public internet.

Getting Started

The quickest way to try Paperclip is:

npx --registry https://registry.npmjs.org paperclipai onboard --yes

Alternatively, use Docker:

docker compose -f docker/docker-compose.quickstart.yml up --build

After startup, open:

http://localhost:3100

Paperclip's onboarding flow can then be used to create the initial organization, agents, and work.

Dependencies for

• Node.js 24.11+ — Required for source/development installations.
• pnpm 9+ — Required for installing and developing Paperclip from source.
• PostgreSQL — Used for persistent application data; the local setup can provision its own PostgreSQL instance.
• Docker — Required only when using the Docker deployment method.
• Persistent storage — Required to retain the Paperclip database, configuration, logs, and application data.
• AI agent runtime — Paperclip coordinates external agents such as Claude Code, Codex, OpenClaw, Cursor, Bash agent

Source

Paperclip is open source and available on GitHub:

https://github.com/paperclipai/paperclip