Paperclip is an open source one-person company framework that orchestrates AI agents like employees: org charts, budgets, heartbeat scheduling, governance approvals, and a full audit log. One command spins it up locally. Your agents do the work; you run the board meeting.
Running a one-person company in 2026 no longer means doing everything yourself it means directing a team of AI agents that do the work while you stay focused on strategy. Paperclip is the open source one-person company framework built to make that real. It gives solo founders an org chart, a budget system, a governance layer, and a task tracker for their AI agents all in one self-hosted dashboard. If you also use Apidog to design, mock, and test the APIs your agents interact with, Paperclip completes the stack: Apidog owns the API contract, Paperclip owns the agents that call it. This guide walks through exactly how Paperclip works and how to wire it into a one-person operation starting today.
What Is Paperclip and Why Does the One-Person Company Framework Matter for Apidog Users?
The Paperclip tagline says it directly: "If OpenClaw is an employee, Paperclip is the company."
Paperclip is a Node.js server and React UI that turns your collection of AI agents into a structured organization with titles, reporting lines, monthly budgets, and strategic goals. It is not a chatbot, a prompt manager, or a workflow drag-and-drop builder. It is the control plane for an autonomous company.
Here is why this one-person company framework matters right now.
Most solo founders using AI agents in 2026 are managing chaos. Twenty Claude Code tabs open. No record of which agent touched which file. No cap on token spend. No way to know whether the agent finished the task or hallucinated a completion. Paperclip fixes all of this by treating agents the same way a real company treats employees:
- Org chart — agents have roles, titles, and a manager
- Issues / tasks — every piece of work is tracked with status, priority, and assignee
- Goals — every task traces back to the company mission so agents always know the why
- Heartbeats — agents wake on a schedule, check their task inbox, do the work, report back
- Budgets — monthly token spend limits per agent; when they hit the cap, they stop
- Governance — you approve agent hires and major strategy decisions before they execute
For teams that use Apidog to define and mock the APIs their agents call, Paperclip adds the missing orchestration layer. Apidog tells the agent what the API contract is. Paperclip tells the agent what job to do, when to do it, and how much it's allowed to spend.
Why Solo Founders Are Choosing This One-Person Company Framework over the Apidog-Alone Approach
Apidog is exceptional at API design and testing in isolation. But API design is only one layer of running a product. Paperclip handles the surrounding process: goal decomposition, task assignment, progress tracking, cost visibility, and audit logging. Together, Apidog + Paperclip give a solo founder a complete operating system for a software company where humans set direction and AI agents execute.
Core Features of Paperclip's One-Person Company Framework and Where Apidog Fits
Heartbeats: The Apidog-Compatible Agent Activation Loop
The heartbeat is Paperclip's core execution primitive. On each heartbeat, an agent:
- Calls
GET /api/agents/meto confirm its identity - Calls
GET /api/companies/:id/issues?status=todo,in_progressto read its task inbox - Calls
GET /api/issues/:idto get full context including parent goal ancestry - Does the work (writes code, calls APIs, generates content)
- Calls
PATCH /api/issues/:idwith status update and a comment explaining what it did
This is where Apidog integration shines. If the task involves calling an external API say, pulling customer data to generate a weekly report the agent hits an Apidog mock server during development, then switches to the live endpoint in production without changing a single line of code. Apidog's request validation catches any drift in the API contract before it silently breaks an agent's work.
Org Chart and Goal Hierarchy Apidog as the API Layer
Paperclip's goal hierarchy flows from company → team → agent → task. An agent assigned a task always receives its ancestor chain so a junior agent knows it is writing a blog post as part of "grow SEO traffic" as part of "reach $1M MRR". This context prevents agents from optimizing locally at the expense of the broader objective.
Within this hierarchy, Apidog serves as the API specification layer. You define your internal services in Apidog, publish mock servers for each, and agents reference those Apidog endpoints in their task descriptions. When the API changes, you update the Apidog spec, re-generate the mock, and every downstream agent gets the new contract automatically.
Budget Enforcement Stopping Runaway Spend in Your Apidog Workflow
Every agent in Paperclip has a budgetMonthlyCents field. When the agent's spentMonthlyCents hits that ceiling, it stops accepting tasks. No overrides, no exceptions. For a one-person company running lean, this is the feature that makes the rest possible you can give an agent a $20/month budget and know with certainty it will never exceed it.
When you pair this with Apidog's mock servers, you can run an entire sprint of agent work against mocks (zero token cost) before switching to live AI providers. Prototyping is free; production is budgeted.
Setting Up Paperclip as Your One-Person Company Framework with Apidog {#setup}
Zero-Config Local Start Apidog Connects Immediately
Getting Paperclip running is a single command:
npx paperclipai onboard --yes
This bootstraps an embedded PostgreSQL database, generates a master encryption key, applies all database migrations, and starts the server on http://localhost:3100. No Docker required, no external services needed.
Once running, open the UI, create a company, and define your first goal:
"Build the #1 AI-powered API monitoring tool to $1M MRR."
Then create your first agent for example, a "Backend Engineer" agent that uses the claude_local adapter:
{
"adapterType": "claude_local",
"adapterConfig": {
"model": "claude-opus-4-6",
"maxTokens": 4096
},
"budgetMonthlyCents": 2000
}
Point the agent's tasks at your Apidog mock server. In the task description, reference the Apidog collection URL so the agent has the full API contract available as context.
Connecting Apidog Mocks to Agent Tasks
In Paperclip, task descriptions are rich markdown with full ancestor context. You can embed your Apidog mock base URL directly:
## Task: Add pagination to the /users endpoint
**Apidog Mock Base:** http://localhost:4523/m1/123456/users
**Acceptance criteria:**
- Endpoint accepts `page` and `limit` query params
- Returns `{ data: [], total: 0, page: 1 }` envelope
- Unit test coverage for edge cases (page=0, limit>100)
The agent reads this, calls the Apidog mock to verify the current response shape, writes the implementation, and reports back with a comment.
Running Agents, Tasks, and Heartbeats in the Paperclip One-Person Company Framework with Apidog
Managing Issues Through the Paperclip Apidog Pipeline
The Paperclip CLI gives you full control over the task lifecycle without opening the UI:
# Create a task for an agent to implement a new Apidog-defined endpoint
pnpm paperclipai issue create \
--company-id <id> \
--title "Implement POST /webhooks endpoint per Apidog spec" \
--description "See Apidog collection: http://localhost:4523/..."
# Check task status
pnpm paperclipai issue list --company-id <id> --status in_progress
# Release a task if an agent gets stuck
pnpm paperclipai issue release <issue-id>
Each status change is recorded in the immutable activity log so you always know exactly which agent touched a task and what it said.
Governance and Approvals in the Apidog-Integrated One-Person Company Framework
Paperclip's governance model puts you in the role of the board. Before any agent is hired or any major strategy is approved, Paperclip can require your explicit sign-off:
# Review pending approvals
pnpm paperclipai approval list --company-id <id>
# Approve a new agent hire
pnpm paperclipai approval approve <approval-id> \
--decision-note "Approved. Use Apidog mock for first sprint."
This keeps the one-person company framework from becoming an autonomy disaster. Agents propose; you decide.
Testing, Governance, and Cost Control in Your Paperclip + Apidog One-Person Company Framework Stack
Running the Paperclip Apidog Unit Test Suite
Paperclip ships with a full unit test suite powered by Vitest and end-to-end tests powered by Playwright. Running them is straightforward:
# Run all unit tests
pnpm test:run
# Run end-to-end tests
pnpm test:e2e
# Health check — verify the server and Apidog mock are reachable
curl http://localhost:3100/api/health
The unit test suite covers the core business logic: issue state transitions, budget enforcement, heartbeat run lifecycle, and agent authentication. When you add a custom adapter to connect a new AI provider, running the unit test suite confirms the existing orchestration behavior is unchanged.
In a one-person company framework, this matters more than in a traditional team. You have no code reviewer. The unit test suite and your Apidog contract tests are your safety net.
The Three-Layer Quality Stack: Paperclip + Apidog + Unit Tests
A practical quality pattern for solo founders:
- Apidog defines the API contract and runs automated contract tests on every push
- Paperclip issues contain acceptance criteria that reference the Apidog spec
- Unit tests (Vitest) validate that the implementation matches both
This three-layer approach means a solo founder gets the same quality assurance that a five-person team would have from peer review without the meetings.
Conclusion
Paperclip is the open source one-person company framework that turns a solo founder into a company. It brings org charts, budget controls, governance, goal alignment, heartbeat scheduling, and a full audit trail to AI agent management all self-hosted, all open source, all yours.
For developers who already use Apidog to design and test APIs, adding Paperclip completes the stack. Apidog handles what the API does. Paperclip handles who calls it, when, why, and at what cost. Together they form a one-person company framework that is production-grade from day one: your Apidog mock servers power agent development, your Apidog contract tests validate agent output, and Paperclip's governance layer ensures no agent takes an action you haven't approved.
Get started:
- Bootstrap locally:
npx paperclipai onboard --yes - Open the UI at
http://localhost:3100, create a company, and define your first goal - Add an agent with a
$20/monthbudget and point it at your Apidog mock server - Run
pnpm test:runto verify the unit test suite passes before your first production heartbeat - Approve the first task, watch the agent work, review the audit log
The one-person company is no longer a metaphor. With Paperclip and Apidog, it is an architecture.
FAQ
What is Paperclip? Paperclip is an open source one-person company framework a Node.js server and React UI that orchestrates AI agents with org charts, budgets, heartbeat scheduling, and governance. It is the control plane for running a software company with AI agents instead of human employees.
How does Paperclip integrate with Apidog? Apidog defines the API contracts your agents work against. You embed Apidog mock URLs in Paperclip task descriptions, agents call those mocks during development, and Apidog's contract tests validate the final implementation. Paperclip handles the orchestration; Apidog handles the API specification.
Is Paperclip suitable for a true one-person company? Yes. The zero-config local setup (npx paperclipai onboard --yes) requires no infrastructure. Budget limits prevent runaway costs. The heartbeat system handles recurring work automatically. Tailscale integration lets you manage your agents from your phone. It scales from local to cloud with the same configuration.
How do I run the unit tests? Run pnpm test:run for the Vitest unit test suite, or pnpm test:e2e for the Playwright end-to-end tests. A health check against http://localhost:3100/api/health confirms the server is running correctly before testing.
What AI agents does Paperclip support? Paperclip supports Claude (local and via OpenClaw), Codex, Cursor, Gemini, OpenCode, and any agent that speaks HTTP or runs as a local process. The adapter system is open if your agent can receive a heartbeat, it can be hired.
Is Paperclip open source? Yes. Paperclip is MIT-licensed and actively maintained at github.com/paperclipai/paperclip. The plugin SDK, adapter packages, and skill definitions are all published as scoped NPM packages under @paperclipai/*.
