Paperclip 是人们用于管理工作场景 AI Agent 的应用。

面向 AI Agent 团队的开源编排系统。

如果 OpenClaw 是一名_员工_，那么 Paperclip 就是这家_公司_。

Paperclip 是一个 Node.js 服务器和 React UI，用于编排一支 AI Agent 团队来经营业务。你可以接入自己的 Agent、分配目标，并从一个仪表盘追踪工作进展和成本。

它看起来像一个任务管理器。但在底层，它提供组织架构图、预算、治理、目标对齐和 Agent 协调能力。

管理业务目标，而不是 pull request。

步骤	示例
01	定义目标：“打造月经常性收入达到 100 万美元的第一 AI 笔记应用。”
02	组建团队：CEO、CTO、工程师、设计师、营销人员——任何机器人、任何供应商。
03	审批并运行：审查战略，设定预算，启动执行，并从仪表盘监控。

如果你符合以下情况，Paperclip 适合你

• ✅ 你希望构建自主 AI 公司
• ✅ 你需要让多种不同 Agent（OpenClaw、Codex、Claude、Cursor）围绕共同目标协同工作
• ✅ 你同时打开了 20 个 Claude Code 终端，却不知道每个终端在做什么
• ✅ 你希望 Agent 能够全天候自主运行，同时仍可审计工作并在必要时介入
• ✅ 你希望监控成本并执行预算限制
• ✅ 你希望采用一种类似任务管理器的 Agent 管理流程
• ✅ 你希望能通过手机管理自主业务

要让一个 AI Agent 组织真正产出成果，任务、组织、训练和基础设施这四项必须同时运作。Paperclip 正是围绕这四大支柱构建的。

支柱	面向对象	覆盖内容
Agent 任务管理器——声明意图，Agent 执行，你验证产出。	每个人，每天	任务、审批与审查关卡 · 主动协作的 Agent 同事 · 可审计的例行流程与工作流 · 通过 diff、截图和测试验证
Agent 组织架构图——为人类和 Agent 定义角色、权限与边界。	管理者	人类与 Agent 混合组织架构图 · 职责、委派与专业分工 · 治理：谁可以做什么 · 受范围限制的密钥与公司边界
Agent 员工训练——设计、训练和评估你的 AI 员工。	赋能团队	Skill Studio 与组织级共享技能 · 评估与保存的测试运行 · 主动学习闭环与质量指标 · Agent 绩效评估
Agent 操作系统——让工作得以运行的基础设施。	IT 与平台团队	跨供应商运行时：任意模型、任意 Agent · 沙箱、集成与 MCP 服务器 · SSO、GRC、RBAC 与成本控制 · 数据隐私、内部追踪数据收集与数据价值累积

任意 Agent、任意运行时，共用一张组织架构图。只要它能接收 heartbeat，就会被录用。	每项任务都可追溯至公司使命。Agent 知道要做_什么_，也知道_为什么_做。	Agent 按计划唤醒、检查工作并采取行动。委派可沿组织架构图向上和向下流动。
每个 Agent 都有月度预算。达到限额时便会停止，不会发生失控成本。	一次部署，运行多家公司。完整的数据隔离。为你的业务组合提供一个控制平面。	每段对话均被追踪，每项决策均可解释。提供完整工具调用追踪和不可变审计日志。
可随时审批录用、覆盖战略、暂停或终止任意 Agent。	层级、角色和汇报关系。你的 Agent 有上司、职位和岗位说明书。	可从任何地点监控和管理你的自主业务。

Paperclip 解决的问题

没有 Paperclip	使用 Paperclip
❌ 你打开了 20 个 Claude Code 标签页，无法追踪各自的工作内容。重启后会丢失一切。	✅ 任务以工单为中心，对话采用线程形式，session 可跨重启持久保存。
❌ 你需要从多个位置手动收集上下文，提醒机器人你实际在做什么。	✅ 上下文从任务流向项目和公司目标——你的 Agent 始终知道该做什么，以及为何这么做。
❌ Agent 配置文件夹杂乱无章，你不断重新发明任务管理、通信和 Agent 间协调机制。	✅ Paperclip 开箱即提供组织架构、工单、委派和治理功能——让你运营一家公司，而不是管理一堆脚本。
❌ 失控循环浪费数百美元的 token，在你意识到发生了什么之前就耗尽配额。	✅ 成本追踪会展示 token 预算，并在 Agent 额度耗尽时限制其运行。管理者可通过预算确定优先级。
❌ 你有周期性工作（客户支持、社交媒体、报告），却必须记得手动启动它们。	✅ heartbeat 可按计划处理常规工作，管理层只需监督。
❌ 有了一个想法后，你还得找到仓库、启动 Claude Code、保持标签页开启并持续盯着它。	✅ 在 Paperclip 中添加一项任务即可。你的编程 Agent 会持续执行，直至完成；管理层随后审查其工作。

Paperclip 正确处理了复杂的编排细节。

原子化执行。	任务检出和预算执行均为原子操作，因此不会重复工作，也不会失控支出。
持久化 Agent 状态。	Agent 可跨 heartbeat 恢复相同任务上下文，而非每次从头开始。
运行时技能注入。	Agent 可在运行时学习 Paperclip 工作流和项目上下文，无需重新训练。
可回滚的治理。	审批关卡会被强制执行，配置修改拥有版本记录，错误变更可被安全回滚。
目标感知执行。	任务携带完整目标继承链，使 Agent 始终看到“为什么”，而不仅是一个标题。
可移植的公司模板。	可导出和导入组织、Agent 与技能，并支持密钥清理和冲突处理。
真正的多公司隔离。	每个实体均限定在公司作用域内，因此一次部署可运行多家公司，并拥有独立数据和审计轨迹。

Paperclip 是一个完整控制平面，而不是包装器。在你尝试自行构建以下能力之前，请先了解它已经存在：

┌──────────────────────────────────────────────────────────────┐
│                       PAPERCLIP SERVER                       │
│                                                              │
│  ┌───────────┐  ┌───────────┐  ┌───────────┐  ┌───────────┐  │
│  │Identity & │  │  Work &   │  │ Heartbeat │  │Governance │  │
│  │  Access   │  │   Tasks   │  │ Execution │  │& Approvals│  │
│  └───────────┘  └───────────┘  └───────────┘  └───────────┘  │
│                                                              │
│  ┌───────────┐  ┌───────────┐  ┌───────────┐  ┌───────────┐  │
│  │ Org Chart │  │Workspaces │  │  Plugins  │  │  Budget   │  │
│  │ & Agents  │  │ & Runtime │  │           │  │ & Costs   │  │
│  └───────────┘  └───────────┘  └───────────┘  └───────────┘  │
│                                                              │
│  ┌───────────┐  ┌───────────┐  ┌───────────┐  ┌───────────┐  │
│  │ Routines  │  │ Secrets & │  │ Activity  │  │  Company  │  │
│  │& Schedules│  │  Storage  │  │ & Events  │  │Portability│  │
│  └───────────┘  └───────────┘  └───────────┘  └───────────┘  │
└──────────────────────────────────────────────────────────────┘
         ▲              ▲              ▲              ▲
   ┌─────┴─────┐  ┌─────┴─────┐  ┌─────┴─────┐  ┌─────┴─────┐
   │  Claude   │  │   Codex   │  │   CLI     │  │ HTTP/web  │
   │   Code    │  │           │  │  agents   │  │   bots    │
   └───────────┘  └───────────┘  └───────────┘  └───────────┘

身份与访问控制	提供两种部署模式（受信任本地模式或认证模式）、董事会用户、Agent API key、短期运行 JWT、公司成员关系、邀请流程和 OpenClaw 引导。每一项变更请求都可追溯至具体操作者。
组织架构图与 Agent	Agent 拥有角色、职务、汇报关系、权限和预算。适配器示例与图中一致：Claude Code、Codex、Cursor/Gemini/bash 等 CLI Agent、OpenClaw 等 HTTP/webhook 机器人，以及外部适配器插件。只要它能接收 heartbeat，就会被录用。
工作与任务系统	Issue 包含公司、项目、目标和父级关联；提供带执行锁的原子检出、一级 blocker 依赖、评论、文档、附件、工作产物、标签和收件箱状态。不会重复工作，也不会丢失上下文。
Heartbeat 执行	基于数据库的唤醒队列，支持合并处理、预算检查、工作区解析、密钥注入、技能加载和适配器调用。运行会产生结构化日志、成本事件、session 状态和审计轨迹；恢复机制会自动处理孤立运行。
工作区与运行时	提供项目工作区、隔离执行工作区（git worktree、operator 分支）和运行时服务（开发服务器、预览 URL）。Agent 每次都能在正确目录和正确上下文中工作。
治理与审批	提供董事会审批工作流、包含审查/审批阶段的执行策略、决策追踪、预算硬停止、Agent 暂停/恢复/终止，以及完整审计日志。未经你的签字确认，任何内容都不会交付。
预算与成本控制	按公司、Agent、项目、目标、Issue、供应商和模型追踪 token 与成本。支持包含预警阈值和硬停止的范围化预算策略。超支会自动暂停 Agent 并取消排队工作。
例行任务与计划	支持通过 cron、webhook 和 API 触发的周期性任务，并提供并发与补跑策略。每次例行任务执行都会创建一个被追踪的 Issue 并唤醒分配的 Agent——无需手动启动。
插件	实例级插件系统，具备进程外 worker、能力门控的主机服务、作业调度、工具暴露和 UI 贡献能力。无需 fork Paperclip 即可扩展。
密钥与存储	支持实例和公司级密钥、加密本地存储、供应商支持的对象存储、附件和工作产物。敏感值不会进入 prompt，除非某次受限运行明确需要它们。
活动与事件	变更操作、heartbeat 状态变化、成本事件、审批、评论和工作产物都会被记录为持久活动，使运营人员能够审计发生了什么及其原因。
公司可移植性	可导出和导入完整组织——包括 Agent、技能、项目、例行任务和 Issue——并支持密钥清理和冲突处理。一次部署可运行多家公司，实现完整数据隔离。

不是聊天机器人。	Agent 有工作岗位，而不是聊天窗口。
不是 Agent 框架。	Paperclip 不告诉你如何构建 Agent，而是告诉你如何运营一家由 Agent 组成的公司。
不是工作流构建器。	没有拖放式管道。Paperclip 对公司进行建模——包括组织架构、目标、预算和治理。
不是 prompt 管理器。	Agent 自带 prompt、模型和运行时；Paperclip 管理它们所工作的组织。
不是单 Agent 工具。	这是面向团队的工具。如果你只有一个 Agent，可能不需要 Paperclip；如果你有 20 个，则肯定需要。
不是代码审查工具。	Paperclip 编排工作，而不是 pull request。请使用你自己的审查流程。

开源。可自托管。无需 Paperclip 账户。

curl -fsSLO https://paperclip.ing/install.sh
curl -fsSLO https://paperclip.ing/install.sh.sha256
if command -v sha256sum >/dev/null 2>&1; then
  sha256sum -c install.sh.sha256
else
  shasum -a 256 -c install.sh.sha256
fi
bash install.sh

安装程序会确保 Node.js 20 或更高版本可用，将受管理的 Paperclip CLI 安装到 ~/.paperclip/cli 下，并启动交互式引导流程。它还可以在受支持的 Linux 和 macOS 系统上将 Paperclip 安装为后台服务。校验和可以检测传输或发布错误，但它与脚本来自同一源；当你需要独立托管的来源时，请使用带 release tag 或固定 commit 的 GitHub 副本。

对于非交互式的受管理安装：

curl -fsSL https://paperclip.ing/install.sh | bash -s -- --no-prompt --no-onboard
paperclipai onboard --yes

通过管道执行的形式要求系统已预先安装受支持的 Node.js、npm 和 npx。如果需要引导安装 Node.js，请在运行前下载并审查 install.sh，以确保不会出现任何特权依赖项安装

Quickstart · Docs · GitHub · Discord · Twitter · Website

Paperclip is the app people use to manage AI agents for work.

Open-source orchestration for teams of AI agents.

If OpenClaw is an employee , Paperclip is the company.

Paperclip is a Node.js server and React UI that orchestrates a team of AI agents to run a business. Bring your own agents, assign goals, and track work and costs from one dashboard.

It looks like a task manager. Under the hood: org charts, budgets, governance, goal alignment, and agent coordination.

Manage business goals, not pull requests.

| Step | Example
---|---|---
01 | Define the goal | "Build the #1 AI note-taking app to $1M MRR."
02 | Hire the team | CEO, CTO, engineers, designers, marketers — any bot, any provider.
03 | Approve and run | Review strategy. Set budgets. Hit go. Monitor from the dashboard.

Paperclip is right for you if

• ✅ You want to build autonomous AI companies
• ✅ You coordinate many different agents (OpenClaw, Codex, Claude, Cursor) toward a common goal
• ✅ You have 20 simultaneous Claude Code terminals open and lose track of what everyone is doing
• ✅ You want agents running autonomously 24/7 , but still want to audit work and chime in when needed
• ✅ You want to monitor costs and enforce budgets
• ✅ You want a process for managing agents that feels like using a task manager
• ✅ You want to manage your autonomous businesses from your phone

Four things have to work for an organization of AI agents to actually produce: the tasks, the org, the training, and the infrastructure. Paperclip is built around exactly those four pillars.

Pillar	Built for	What it covers
Agentic Task Manager — Declare intent. Agents work. You verify the output.	Everyone, daily	Tasks, approvals & review gates · proactive agent coworkers · auditable routines & workflows · verify from diffs, screenshots & tests
Org Chart for Agents — Roles, permissions & boundaries for humans and agents.	Managers	Mixed human + agent org chart · responsibilities, delegation, specialization · governance: who can do what · scoped secrets & company boundaries
Agent Employee Training — Design, train & evaluate your AI employees.	Enablers	Skill Studio & shared org-wide skills · evals & saved test runs · active learning loops & quality metrics · performance reviews for agents
Agentic OS — The infrastructure that makes the work run.	IT & platform	Cross-provider runtime: any model, any agent · sandboxing, integrations & MCP servers · SSO, GRC, RBAC & cost controls · data privacy, internal trace collection, compounding data value

Any agent, any runtime, one org chart. If it can receive a heartbeat, it's hired.	Every task traces back to the company mission. Agents know what to do and why.	Agents wake on a schedule, check work, and act. Delegation flows up and down the org chart.
Monthly budgets per agent. When they hit the limit, they stop. No runaway costs.	One deployment, many companies. Complete data isolation. One control plane for your portfolio.	Every conversation traced. Every decision explained. Full tool-call tracing and immutable audit log.
Approve hires, override strategy, pause or terminate any agent — at any time.	Hierarchies, roles, reporting lines. Your agents have a boss, a title, and a job description.	Monitor and manage your autonomous businesses from anywhere.

Problems Paperclip solves

Without Paperclip	With Paperclip
❌ You have 20 Claude Code tabs open and can't track which one does what. On reboot you lose everything.	✅ Tasks are ticket-based, conversations are threaded, sessions persist across reboots.
❌ You manually gather context from several places to remind your bot what you're actually doing.	✅ Context flows from the task up through the project and company goals — your agent always knows what to do and why.
❌ Folders of agent configs are disorganized and you're re-inventing task management, communication, and coordination between agents.	✅ Paperclip gives you org charts, ticketing, delegation, and governance out of the box — so you run a company, not a pile of scripts.
❌ Runaway loops waste hundreds of dollars of tokens and max your quota before you even know what happened.	✅ Cost tracking surfaces token budgets and throttles agents when they're out. Management prioritizes with budgets.
❌ You have recurring jobs (customer support, social, reports) and have to remember to manually kick them off.	✅ Heartbeats handle regular work on a schedule. Management supervises.
❌ You have an idea, you have to find your repo, fire up Claude Code, keep a tab open, and babysit it.	✅ Add a task in Paperclip. Your coding agent works on it until it's done. Management reviews their work.

Paperclip handles the hard orchestration details correctly.

|
---|---
Atomic execution. | Task checkout and budget enforcement are atomic, so no double-work and no runaway spend.
Persistent agent state. | Agents resume the same task context across heartbeats instead of restarting from scratch.
Runtime skill injection. | Agents can learn Paperclip workflows and project context at runtime, without retraining.
Governance with rollback. | Approval gates are enforced, config changes are revisioned, and bad changes can be rolled back safely.
Goal-aware execution. | Tasks carry full goal ancestry so agents consistently see the "why," not just a title.
Portable company templates. | Export/import orgs, agents, and skills with secret scrubbing and collision handling.
True multi-company isolation. | Every entity is company-scoped, so one deployment can run many companies with separate data and audit trails.

Paperclip is a full control plane, not a wrapper. Before you build any of this yourself, know that it already exists:

┌──────────────────────────────────────────────────────────────┐
│                       PAPERCLIP SERVER                       │
│                                                              │
│  ┌───────────┐  ┌───────────┐  ┌───────────┐  ┌───────────┐  │
│  │Identity & │  │  Work &   │  │ Heartbeat │  │Governance │  │
│  │  Access   │  │   Tasks   │  │ Execution │  │& Approvals│  │
│  └───────────┘  └───────────┘  └───────────┘  └───────────┘  │
│                                                              │
│  ┌───────────┐  ┌───────────┐  ┌───────────┐  ┌───────────┐  │
│  │ Org Chart │  │Workspaces │  │  Plugins  │  │  Budget   │  │
│  │ & Agents  │  │ & Runtime │  │           │  │ & Costs   │  │
│  └───────────┘  └───────────┘  └───────────┘  └───────────┘  │
│                                                              │
│  ┌───────────┐  ┌───────────┐  ┌───────────┐  ┌───────────┐  │
│  │ Routines  │  │ Secrets & │  │ Activity  │  │  Company  │  │
│  │& Schedules│  │  Storage  │  │ & Events  │  │Portability│  │
│  └───────────┘  └───────────┘  └───────────┘  └───────────┘  │
└──────────────────────────────────────────────────────────────┘
         ▲              ▲              ▲              ▲
   ┌─────┴─────┐  ┌─────┴─────┐  ┌─────┴─────┐  ┌─────┴─────┐
   │  Claude   │  │   Codex   │  │   CLI     │  │ HTTP/web  │
   │   Code    │  │           │  │  agents   │  │   bots    │
   └───────────┘  └───────────┘  └───────────┘  └───────────┘

Identity & Access — Two deployment modes (trusted local or authenticated), board users, agent API keys, short-lived run JWTs, company memberships, invite flows, and OpenClaw onboarding. Every mutating request is traced to an actor.	Org Chart & Agents — Agents have roles, titles, reporting lines, permissions, and budgets. Adapter examples match the diagram: Claude Code, Codex, CLI agents such as Cursor/Gemini/bash, HTTP/webhook bots such as OpenClaw, and external adapter plugins. If it can receive a heartbeat, it's hired.
Work & Task System — Issues carry company/project/goal/parent links, atomic checkout with execution locks, first-class blocker dependencies, comments, documents, attachments, work products, labels, and inbox state. No double-work, no lost context.	Heartbeat Execution — DB-backed wakeup queue with coalescing, budget checks, workspace resolution, secret injection, skill loading, and adapter invocation. Runs produce structured logs, cost events, session state, and audit trails. Recovery handles orphaned runs automatically.
Workspaces & Runtime — Project workspaces, isolated execution workspaces (git worktrees, operator branches), and runtime services (dev servers, preview URLs). Agents work in the right directory with the right context every time.	Governance & Approvals — Board approval workflows, execution policies with review/approval stages, decision tracking, budget hard-stops, agent pause/resume/terminate, and full audit logging. Nothing ships without your sign-off.
Budget & Cost Control — Token and cost tracking by company, agent, project, goal, issue, provider, and model. Scoped budget policies with warning thresholds and hard stops. Overspend pauses agents and cancels queued work automatically.	Routines & Schedules — Recurring tasks with cron, webhook, and API triggers. Concurrency and catch-up policies. Each routine execution creates a tracked issue and wakes the assigned agent — no manual kick-offs needed.
Plugins — Instance-wide plugin system with out-of-process workers, capability-gated host services, job scheduling, tool exposure, and UI contributions. Extend Paperclip without forking it.	Secrets & Storage — Instance and company secrets, encrypted local storage, provider-backed object storage, attachments, and work products. Sensitive values stay out of prompts unless a scoped run explicitly needs them.
Activity & Events — Mutating actions, heartbeat state changes, cost events, approvals, comments, and work products are recorded as durable activity so operators can audit what happened and why.	Company Portability — Export and import entire organizations — agents, skills, projects, routines, and issues — with secret scrubbing and collision handling. One deployment, many companies, complete data isolation.

|
---|---
Not a chatbot. | Agents have jobs, not chat windows.
Not an agent framework. | We don't tell you how to build agents. We tell you how to run a company made of them.
Not a workflow builder. | No drag-and-drop pipelines. Paperclip models companies — with org charts, goals, budgets, and governance.
Not a prompt manager. | Agents bring their own prompts, models, and runtimes. Paperclip manages the organization they work in.
Not a single-agent tool. | This is for teams. If you have one agent, you probably don't need Paperclip. If you have twenty — you definitely do.
Not a code review tool. | Paperclip orchestrates work, not pull requests. Bring your own review process.

Open source. Self-hosted. No Paperclip account required.

curl -fsSLO https://paperclip.ing/install.sh
curl -fsSLO https://paperclip.ing/install.sh.sha256
if command -v sha256sum >/dev/null 2>&1; then
  sha256sum -c install.sh.sha256
else
  shasum -a 256 -c install.sh.sha256
fi
bash install.sh

The installer ensures Node.js 20 or newer is available, installs a managed Paperclip CLI under ~/.paperclip/cli, and starts interactive onboarding. It can also install Paperclip as a background service on supported Linux and macOS systems. The checksum detects transfer or publishing mistakes, but it is served from the same origin as the script; use a release-tag or commit-pinned GitHub copy when you need an independently hosted source.

For a non-interactive managed install:

curl -fsSL https://paperclip.ing/install.sh | bash -s -- --no-prompt --no-onboard
paperclipai onboard --yes

The piped form requires supported Node.js, npm, and npx to already be present. If Node.js bootstrap is required, download and review install.sh before running it so no privileged dependency-install command is accepted through a pipe.

To try Paperclip without installing anything permanently:

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

Troubleshooting: private npm registry.npmrc

If this fails with an E404 for paperclipai (or similar) and you use a private npm registry (for example GitHub Packages) via a global ~/.npmrc, npx may be resolving paperclipai against that private registry instead of the public npm registry.

Diagnostic:

Workaround (cross-platform; force the public npm registry for this command):

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

That quickstart path now defaults to trusted local loopback mode for the fastest first run. To start in authenticated/private mode instead, choose a bind preset explicitly:

paperclipai onboard --yes --bind lan
# or:
paperclipai onboard --yes --bind tailnet

If you already have Paperclip configured, rerunning onboard keeps the existing config in place. Use paperclipai configure to edit settings.

See doc/INSTALLING.md for pinned versions, canary and git-ref installs, updates, rollback, service management, and uninstalling.

Or manually:

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

This starts the API server at http://localhost:3100. An embedded PostgreSQL database is created automatically — no setup required.

Requirements: Node.js 20+, pnpm 9.15+

What does a typical setup look like? Locally, a single Node.js process manages an embedded Postgres and local file storage. For production, point it at your own Postgres and deploy however you like. Configure projects, agents, and goals — the agents take care of the rest.

If you're a solo entrepreneur you can use Tailscale to access Paperclip on the go. Then later you can deploy to e.g. Vercel when you need it.

Can I run multiple companies? Yes. A single deployment can run an unlimited number of companies with complete data isolation.

How is Paperclip different from agents like OpenClaw or Claude Code? Paperclip uses those agents. It orchestrates them into a company — with org charts, budgets, goals, governance, and accountability.

Why should I use Paperclip instead of just pointing my OpenClaw to Asana or Trello? Agent orchestration has subtleties in how you coordinate who has work checked out, how to maintain sessions, monitoring costs, establishing governance - Paperclip does this for you.

(Bring-your-own-ticket-system is on the Roadmap)

Do agents run continuously? By default, agents run on scheduled heartbeats and event-based triggers (task assignment, @-mentions). You can also hook in continuous agents like OpenClaw. You bring your agent and Paperclip coordinates.

pnpm dev              # Full dev (API + UI, watch mode)
pnpm dev:once         # Full dev without file watching
pnpm dev:server       # Server only
pnpm dev:mobile       # Serve prebuilt UI on :3101 for phones/tablets (proxies /api → :3100)
pnpm dev:both         # Run `pnpm dev` and `pnpm dev:mobile` together
pnpm build            # Build all
pnpm typecheck        # Type checking
pnpm test             # Cheap default test run (Vitest only)
pnpm test:watch       # Vitest watch mode
pnpm test:e2e         # Playwright browser suite
pnpm db:generate      # Generate DB migration
pnpm db:migrate       # Apply migrations

pnpm test does not run Playwright. Browser suites stay separate and are typically run only when working on those flows or in CI.

See doc/DEVELOPING.md for the full development guide.

• ✅ Plugin system (e.g. add a knowledge base, custom tracing, queues, etc)
• ✅ Get OpenClaw / claw-style agent employees
• ✅ companies.sh - import and export entire organizations
• ✅ Easy AGENTS.md configurations
• ✅ Skills Manager, Skill Studio & Skills Store
• ✅ Scheduled Routines
• ✅ Better Budgeting
• ✅ Agent Reviews and Approvals
• ✅ Multiple Human Users
• ✅ Cloud / Sandbox agents (e2b, Cloudflare, Daytona, Modal, Novita, self-hosted Kubernetes)
• ✅ Artifacts & Work Products
• ✅ Deep Planning (planning mode, revisioned plans, plan approvals)
• ✅ Enforced Outcomes (watchdogs, recovery actions, review gates)
• ✅ MCP Tool Gateway & Apps (governed tool access)
• ✅ Secrets Manager with per-agent access
• ✅ Activity log & action attribution
• ✅ Self-healing runs & automatic recovery
• ✅ Agent evals & feedback
• ⚪ Memory / Knowledge
• ⚪ MAXIMIZER MODE
• ⚪ Work Queues
• ⚪ Self-Organization
• ⚪ Automatic Organizational Learning
• ⚪ CEO Chat
• 🟡 Cloud deployments (multi-tenant isolation & company Import/Export shipped)
• ⚪ Desktop App
• ⚪ Bring-your-own-ticket-system (Asana / Linear / Jira as on-ramps)
• ⚪ Connected Apps (one-click integrations, e.g. Vercel)

This is the short roadmap preview. See the full roadmap in ROADMAP.md.

Community & Plugins

Find Plugins and more at awesome-paperclip

Paperclip ships with opt-in OpenTelemetry auto-instrumentation for the server (traces only). It activates when OTEL_EXPORTER_OTLP_ENDPOINT is set and supports grpc, http/protobuf, and http/json via the standard OTEL_EXPORTER_OTLP_PROTOCOL env var. The @opentelemetry/* packages are optional peer dependencies — install them only if you want tracing. See doc/observability.md for install commands and the full env-var reference.

Paperclip collects anonymous usage telemetry to help us understand how the product is used and improve it. No personal information, issue content, prompts, file paths, or secrets are ever collected. Private repository references are hashed with a per-install salt before being sent.

Contributors changing emitted telemetry events should follow the Telemetry Data Contract. For proposed first-party events that are not in the generated contract yet, follow Telemetry Workflow.

Telemetry is enabled by default and can be disabled with any of the following:

Method	How
Environment variable	PAPERCLIP_TELEMETRY_DISABLED=1
Standard convention	DO_NOT_TRACK=1
CI environments	Automatically disabled when CI=true
Config file	Set telemetry.enabled: false in your Paperclip config

We welcome contributions. See the contributing guide for details.

Community

MIT © 2026 Paperclip Labs, Inc

---

Open source under MIT. Built for people who want to get work done, not babysit agents.