paperclip: 69,700 Stars for Open-Source Agent Workplace

OpenCode: The Open-Source AI Coding Agent That Overtook Claude • n8n AI Workflow Automation 2026

┌──────────────────────────────────────────────────────┐
│           paperclip Agent Workplace                  │
│                                                      │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐          │
│  │  Agent 1 │  │  Agent 2 │  │  Agent N │          │
│  │ (Coder)  │  │(Research) │  │  (QA)    │          │
│  └────┬─────┘  └────┬─────┘  └────┬─────┘          │
│       │              │             │                 │
│  ┌────▼──────────────▼─────────────▼─────┐          │
│  │        Agent Orchestration Layer       │          │
│  │   Task Queue  │  Memory  │  Routing    │          │
│  └──────────────────────────────────────┘          │
└──────────────────────────────────────────────────────┘

paperclip architecture: multi-agent coordination platform

Introduction #

Last week I tried to migrate a 50K-line codebase with 5 AI CLIs. Three failed, one produced broken code, and the last one took 47 minutes because it kept losing its context. The problem wasn’t the agents — they were all excellent individually. The problem was there was no system to coordinate them. paperclip (69,700 GitHub stars) is the open-source solution to exactly this problem. It’s an agent workplace — a platform where you don’t just run AI agents, you manage them as a team: assigning tasks, tracking progress, routing outputs between agents, and deploying everything self-hosted. Born from the observation that single-agent workflows cap out at a certain complexity level, paperclip treats AI agents as team members with roles, responsibilities, and conversation history.

What Is paperclip? #

paperclip is an open-source agent workplace platform designed for teams and solo developers who need to orchestrate multiple AI agents simultaneously. Think of it as Jira for AI agents — a structured environment where agents are assigned tasks, progress is tracked in real-time, and the output of one agent becomes the input of another.

Key capabilities:

• Multi-agent task assignment — Assign different tasks to different agents with specialized prompts
• Conversation history — Every agent interaction is logged, searchable, and replayable
• Self-hosted deployment — Run everything on your own infrastructure (Docker, Kubernetes, or bare metal)
• Agent marketplace — Import pre-built agent templates or create your own

paperclip is built with TypeScript (frontend) and Python (backend agent runtime). It supports integration with Claude Code, Codex CLI, OpenCode, and any OpenAI-compatible API endpoint.

How paperclip Works #

paperclip operates on a three-layer architecture:

1. Agent Layer #

Each agent runs as an isolated process with its own context window, system prompt, and tool permissions. Agents are assigned a role (Coder, Researcher, Reviewer, Deployer) and a task description.

# Define an agent in paperclip
agent = {
    "role": "coder",
    "model": "claude-sonnet-4-20250514",
    "system_prompt": "You are a Python developer. Write clean, tested code.",
    "tools": ["filesystem", "terminal", "git"],
    "max_tokens": 16384,
    "temperature": 0.3,
}

2. Orchestration Layer #

The orchestration layer manages the flow between agents. It implements:

• Task queue — FIFO or priority-based task scheduling
• Context routing — Pass the output of agent A as context to agent B
• Error handling — Retry failed agents, fallback to alternative models
• Resource management — Track API token usage per agent

3. Interface Layer #

The web-based UI provides:

• Real-time agent activity monitoring
• Task board (Kanban-style)
• Conversation replay
• Deployment dashboard

Installation & Setup #

Docker Compose (Recommended) #

paperclip is a web-based agent workplace. The easiest way to run it is with Docker Compose:

# Start the stack
docker compose up -d

# Access the UI at http://localhost:3000

Set your API keys in the web UI or via the .env file:

• ANTHROPIC_API_KEY
• OPENAI_API_KEY

For full Docker Compose configuration, see the official docs at https://github.com/paperclipai/paperclip/blob/master/doc/DOCKER.md

Cloud Deployment #

For production, paperclip supports multiple deployment modes:

# Deploy on DigitalOcean using the provided scripts
curl -sSL https://paperclip.ai/deploy/do | bash

# Or deploy on AWS ECS Fargate
docker build -t paperclip .
docker push your-registry/paperclip:latest
# Follow ECS deployment runbook in docs/DEPLOYMENT-MODES.md

Integration with Claude Code, Codex CLI, OpenCode, and Custom Agents #

paperclip’s agent runtime is designed to be API-agnostic. It connects to any agent through a standardized interface:

Built-in Agent Templates #

paperclip ships with pre-configured agent templates:

# Templates for common agent roles
templates:
  coder:
    model: claude-sonnet-4-20250514
    system_prompt: "Write clean, tested code. Use type hints."
    tools: [fs, terminal, git]
  reviewer:
    model: claude-sonnet-4-20250514
    system_prompt: "Review code for bugs, security issues, and style violations."
    tools: [fs, diff]
  researcher:
    model: claude-opus-4-20250514
    system_prompt: "Research the topic thoroughly. Cite sources."
    tools: [web_search, file_read]
  deployer:
    model: claude-haiku-4-20250514
    system_prompt: "Write deployment scripts and infrastructure code."
    tools: [fs, terminal]

Connecting External Agents #

To connect Claude Code, Codex CLI, or OpenCode:

# Use the CLI hub to register an agent
paperclip agent register \
  --name "my-codex" \
  --type "openai-compatible" \
  --endpoint "http://localhost:4000/v1" \
  --api-key "sk-codex-..."

# Verify connection
paperclip agent test my-codex
# Response: OK (latency: 42ms, model: codex-cli-v0.3)

Agent Communication Protocol #

Agents communicate through paperclip’s message bus using JSON-RPC:

// Message format for agent-to-agent communication
{
  "from": "coder",
  "to": "reviewer",
  "type": "task",
  "payload": {
    "file": "/src/main.py",
    "task": "review",
    "context": "PR #42 - auth refactoring",
    "priority": "high"
  }
}

# Monitor agent messages in real-time
paperclip monitor --follow

# View message history for a session
paperclip history --session abc123 --format json

For self-hosted agent infrastructure, I recommend HTStack for stable network connections or WebShare data-center proxies for agents that need external API access.

Benchmarks / Real-World Use Cases #

Multi-Agent vs Single-Agent Task Completion #

In a controlled test on a 10K-line Python refactoring task:

| Approach | Time | Success Rate | Code Quality Score | |