Paperclip: How to Run a One-Person Company with This Open Source Framework

Paperclip is an open source framework that lets you run a one-person company by orchestrating AI agents as if they were employees—org charts, budgets, scheduled work cycles (“heartbeats”), approvals, and audit logs are all built in. You spin it up locally with a single command. Your AI agents handle the execution; you focus on strategy.

Try Apidog today

Running a one-person company in 2026 is about directing a purpose-built team of AI agents, not working solo on everything. Paperclip provides solo founders with an org chart, budget system, governance layer, and task tracker for AI agents—all in a single, self-hosted dashboard. If you use Apidog to design, mock, and test APIs for your agents, Paperclip completes the automation stack: Apidog defines API contracts, Paperclip manages the agents that use them. This guide shows how to implement Paperclip for your one-person operation right now.

💡 Grab Apidog (free) before your first Paperclip heartbeat. Embed Apidog mock URLs in task descriptions so agents build against perfect contracts—zero cost, zero surprises. Switch to live APIs later, with Apidog tests catching contract drift before budget is spent.

What Is Paperclip and Why Does the One-Person Company Framework Matter for Apidog Users?

Paperclip’s tagline: "If OpenClaw is an employee, Paperclip is the company."

Paperclip is a Node.js server and React UI that turns your AI agents into an organized company with proper roles, reporting lines, budgets, and strategic goals. It isn’t a chatbot or prompt manager—it’s a control plane for autonomous operations.

Why use this framework today?

Solo founders with AI agents often manage disorganized chaos—multiple browser tabs, no audit trail, no cost control, and no clear task tracking. Paperclip fixes this by treating agents like employees:

• Org chart — agents have roles, titles, and managers
• Issues / tasks — all work is tracked by status, priority, and assignee
• Goals — every task links to company objectives for context
• Heartbeats — agents wake on schedule, check tasks, work, and report back
• Budgets — token spend capped per agent
• Governance — human approval required for agent hires and major decisions

If you use Apidog to define and mock APIs that your agents call, Paperclip adds orchestration. Apidog specifies what the API is. Paperclip controls who calls it, when, and how much they can spend.

Why Solo Founders Choose Paperclip Over Apidog Alone

Apidog excels at API design and testing, but running a product involves more. Paperclip brings goal decomposition, task assignment, progress tracking, cost visibility, and audit logging. Together, Apidog + Paperclip becomes a full operating system for solo founders: humans set direction; 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 agent execution cycle. Each heartbeat, an agent:

1. Calls GET /api/agents/me to verify identity
2. Calls GET /api/companies/:id/issues?status=todo,in_progress to load its task inbox
3. Calls GET /api/issues/:id to get full context (including goal ancestry)
4. Performs the work (writes code, calls APIs, generates content)
5. Calls PATCH /api/issues/:id to update status and log actions

How Apidog integrates: If a task requires calling an external API, agents use an Apidog mock server during dev. In production, they switch to the live endpoint—no code changes needed. Apidog’s request validation ensures agents catch API contract drift before it breaks real work.

Org Chart and Goal Hierarchy: Apidog as the API Layer

Paperclip’s hierarchy flows: company → team → agent → task. Tasks include their full goal ancestry, so agents always have business context.

Within this, Apidog is the API spec layer. Define services in Apidog, publish mock servers, and reference those endpoints in task descriptions. Update the Apidog spec to propagate changes instantly to all agent-facing mocks.

Budget Enforcement: Stop Runaway Spend in Your Apidog Workflow

Every Paperclip agent has a budgetMonthlyCents. When spentMonthlyCents hits the limit, the agent stops accepting work—no exceptions. For solo founders, this means you can confidently set, for example, a $20/month agent budget.

Combine this with Apidog mocks: run sprints against zero-cost mocks, then move to live APIs with cost controls in place.

Setting Up Paperclip as Your One-Person Company Framework with Apidog

Zero-Config Local Start: Apidog Connects Instantly

Start Paperclip locally with one command:

npx paperclipai onboard --yes

This sets up a local PostgreSQL DB, encryption keys, migrations, and the server at http://localhost:3100. No Docker or extra infrastructure needed.

Open the UI, create a company, and define your first goal:

"Build the #1 AI-powered API monitoring tool to $1M MRR."

Create your first agent (e.g., a "Backend Engineer" using the claude_local adapter):

{
  "adapterType": "claude_local",
  "adapterConfig": {
    "model": "claude-opus-4-6",
    "maxTokens": 4096
  },
  "budgetMonthlyCents": 2000
}

Assign tasks that reference your Apidog mock server. In task descriptions, include the Apidog collection URL so the agent has instant API context.

Connecting Apidog Mocks to Agent Tasks

Paperclip tasks use markdown and include ancestor context. Embed Apidog mock URLs 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)

Agents read this, call the Apidog mock to confirm response shape, implement the task, and report back.

Running Agents, Tasks, and Heartbeats in Paperclip with Apidog

Managing Issues via the Paperclip-Apidog Pipeline

Control task lifecycle from the CLI—no UI needed:

# Create a task for an 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 stuck task
pnpm paperclipai issue release <issue-id>

All status changes are logged immutably, so you always know what happened and which agent acted.

Governance and Approvals in the Apidog-Integrated Framework

Paperclip governance puts you in control. Approve new agents or strategy changes before they execute:

# List 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."

Agents propose; you decide—preventing unwanted autonomy.

Testing, Governance, and Cost Control in Your Paperclip + Apidog Stack

Running the Paperclip-Apidog Test Suite

Paperclip ships with Vitest unit tests and Playwright end-to-end tests:

# Run all unit tests
pnpm test:run

# Run end-to-end tests
pnpm test:e2e

# Health check — verify server and Apidog mock availability
curl http://localhost:3100/api/health

Tests cover business logic (issue transitions, budgets, heartbeat cycles, agent auth). If you add a new AI adapter, rerun tests to ensure orchestrator stability.

For solo founders, these tests plus Apidog contract tests are your automated code reviewer.

The Three-Layer Quality Stack: Paperclip + Apidog + Unit Tests

Follow this actionable QA workflow:

1. Apidog defines API contracts and runs contract tests on every push
2. Paperclip tasks include acceptance criteria referencing the Apidog spec
3. Unit tests (Vitest) ensure implementation matches the spec and business rules

This gives you peer-review level QA—without a team.

Conclusion

Paperclip is the open source one-person company framework that gives solo founders real company infrastructure: org charts, budget controls, governance, goal tracking, heartbeat scheduling, and audit trails for AI agent management. All self-hosted, all open source.

If you use Apidog for API design and testing, integrating Paperclip completes your stack: Apidog governs what the API does; Paperclip manages who calls it, when, why, and at what cost. Together, they deliver a one-person company architecture that is production-ready from day one: Apidog mock servers power agent development, Apidog contract tests validate agent output, and Paperclip’s governance ensures no agent acts without your approval.

Get started:

• Bootstrap locally: npx paperclipai onboard --yes
• Open the UI at http://localhost:3100, create your company, and set your first goal
• Add an agent with a $20/month budget—point it at your Apidog mock server
• Run pnpm test:run to confirm the unit test suite passes before production
• Approve the first task, watch the agent execute, and review the audit log

The one-person company is now an actionable architecture, not just a metaphor.

FAQ

What is Paperclip?

Paperclip is an open source one-person company framework—a Node.js server and React UI that organizes AI agents with org charts, budgets, scheduling, and governance. It is the control plane for running a software company with AI agents.

How does Paperclip integrate with Apidog?

Apidog defines the API contracts your agents work against. Embed Apidog mock URLs in Paperclip task descriptions. Agents call those mocks during development, and Apidog’s contract tests validate implementation. Paperclip manages the orchestration; Apidog manages API specification.

Is Paperclip suitable for a true one-person company?

Yes. The zero-config local setup (npx paperclipai onboard --yes) needs no extra infrastructure. Budget limits prevent runaway spend. Heartbeat scheduling manages recurring work. Tailscale integration enables remote management. Easily scales from local to cloud.

How do I run the unit tests?

Run pnpm test:run for Vitest unit tests, or pnpm test:e2e for Playwright end-to-end tests. A health check at http://localhost:3100/api/health confirms server readiness.

What AI agents does Paperclip support?

Supports Claude (local and via OpenClaw), Codex, Cursor, Gemini, OpenCode, and any HTTP agent or local process. The adapter system is open—if your agent can receive a heartbeat, it can be managed.

Is Paperclip open source?

Yes. Paperclip is MIT-licensed, with code at github.com/paperclipai/paperclip. Plugin SDK, adapters, and skill definitions are on npm under @paperclipai/*.