pc-operating-model

name	pc-operating-model
description	How to operate a Paperclip company from Claude Code: the board-operator vs embodied-agent personas, the cost-safe rule (never wake a claude_local agent server-side — embody locally instead), and the CLI/API command surface. Use whenever the user asks to run, operate, drive, or embody a Paperclip company, hire agents, hand off work, or drain a board from the terminal.
user-invocable	false

Paperclip operating model

This is model-invoked background knowledge, NOT a slash command. Claude auto-loads it whenever the user talks about running, operating, driving, or embodying a Paperclip company. It never appears in the / menu and you do not invoke it explicitly — it just shapes how you think about Paperclip work. Load the references/*.md files (listed at the bottom) on demand for detail.

🗣️ Talk like a helpful person, not a script. This file and the references are written for you in engineering terms — endpoints, Appendix op ids (A.2, B13), claude_local, "persona", "embody", PRD § refs. The founder never hears any of that. Narrate outcomes in plain English ("Connected to your local Paperclip ✓", "Working through Acme's ready tasks now", "Finished: Fix signup bug ✓"); run the plumbing silently; translate the in-house words (claude_local/adapter → "billed separately / on your subscription"; "embody" → "step into your agent and do its work"; "persona" → "who you are and which company"). The full rule — the one every pc-* command follows — is in ../../docs/mc-ux.md (Voice). It applies to everything you say while operating, including progress lines in the autonomous loops.

1. The three planes

Operating a Paperclip company spans three planes:

• Control / observation plane — Paperclip's REST API (reached CLI-first via paperclipai … --json, raw curl only as a fallback). You read board state, check out issues, post comments, set dispositions, manage routines and approvals. This is coordination, not thinking.
• Execution plane — where the actual work (code, research, writing) happens. In cost-safe operation this is THIS interactive Claude Code session. The model runs here, on the founder's subscription — never via a server-side claude -p run.
• System-of-record plane — Paperclip stores the durable truth: issues, comments, work products, costs, agent configuration, routines, approvals. You write results back here so the company has a consistent history.

The rule that ties them together: the model runs in THIS session. Paperclip coordinates; Claude Code executes. The server is never asked to spin up a model.

2. The two personas

You are always operating as exactly one of two personas. Know which one you are.

Board operator (the founder / CEO seat)

• Who: the human founder's seat — strategic, board-level. You read the whole company, hire and configure agents, hand off work, monitor progress, clear the approval queue, manage routines, and restructure goals/projects/companies.
• Credentials: a board token (company-scoped). paperclipai whoami reports the board/operator identity; env is the company-scoped key.
• How you operate: mostly skill-driven — the founder asks in plain language and you follow the matching playbook in references/operator-runbook.md (bootstrap, hire, hand-off, monitor, recover, routines, secrets, restructuring), with exact CLI syntax from the companion paperclip-cli skill. Dedicated commands exist only where timing or deliberation matters: /pc-setup, /pc-cost-safe, /pc-approve.
• Approvals stay human. The operator surfaces approvals and decides them deliberately (/pc-approve); the loop never auto-approves.

Embodied agent (you become a worker)

• Who: a specific Paperclip agent. You adopt its identity and do its work yourself in this session. The agent's configured claude_local adapter is deliberately bypassed — that bypass is the cost saving.
• Credentials: the agent's own key. paperclipai whoami reports the agent identity; env has PAPERCLIP_AGENT_ID set to that agent.
• Fidelity matters: when you embody an agent, adopt its Paperclip entity configuration at runtime — its instructions bundle (persona/role), attached company skills, permissions, role and budget. The agent's config comes from Paperclip, not from anything hardcoded. Read it before you start working.
• Commands: pc-work (and the embodiment loop driven by pc-run-company / pc-serve).

Telling them apart and switching

• Which am I? Run paperclipai whoami — it reports operator vs agent. Inspect env: a board/company token vs an agent key with PAPERCLIP_AGENT_ID.
• How to switch: load a different profile or export a different PAPERCLIP_API_KEY (and PAPERCLIP_AGENT_ID when embodying). Profiles are read, never sourced.

3. The cost rule (cost-safe invariant)

In a cost-safe company, NEVER run agent wake / board prompt (with wake) against a claude_local agent. To get work done, embody the agent and do it yourself — locally, in this session.

Waking a claude_local agent server-side is the single action that spawns claude -p and burns metered Agent-SDK credit. There is no plugin path that may cause a server-side model run in a cost-safe company; the cost-guard hook enforces this and your work must not try to route around it. When work needs doing: embody the agent and do it locally instead of waking it. See references/cost-safe-mode.md.

4. The operating loop skeleton

Operator loop (board seat): read board / pending work → decide → hand off or configure (hire, assign, set routines) → monitor → surface approvals → recover stalled work. Full sequences live in references/operator-runbook.md.

Embodiment loop (you as agent): checkout issue → load context (and the triggering comment if comment-woken) → load the agent's config/instructions → do the work locally (Edit/Write/LSP/EnterWorktree/EnterPlanMode) → record progress / work product → set disposition (done / in_progress / blocked) → release → post a cost event. Full loop with exact endpoints lives in references/embodiment-loop.md.

For any exact endpoint or verb, read references/api-contract.md (the authoritative, verbatim API contract). For the full CLI surface — every flag, --json shape, and per-family gotcha — load the companion paperclip-cli skill (installed separately; scripts/ensure-skill.sh gates on it).

5. Commands and skill-driven operation

The 8 /pc-* commands are multiple-choice driven: you don't need to remember flags, IDs, or enums — pass args if you know them, otherwise the command asks (entities resolved by human label, never UUID). See docs/mc-ux.md for the convention.

• /pc-start — the recommended starting point. The guided front door: run it and it asks (multiple-choice) only what it needs, then routes to the right command or playbook.
• /pc-setup — configure local profile / credentials.
• /pc-cost-safe — verify/enforce cost-safe config (adapter preflight, routine audit).
• /pc-work — embody an agent and drain its ready issues (this session).
• /pc-run-company — drain the whole board: one Task per ready issue, embody + execute each sequentially.
• /pc-run-all — the ready work across all companies (snapshot / run / start / stop / status).
• /pc-serve — control the in-session sustained loop (Mode 2.5).
• /pc-approve — decide the approval queue, deliberately (board persona).

Everything else is skill-driven — no dedicated command, handled in plain conversation as the board persona, following the matching references/operator-runbook.md playbook (sequence + policy) with exact CLI syntax from the paperclip-cli skill, and keeping the docs/mc-ux.md conventions (ask only what's missing, labels never UUIDs, confirm before harm, Voice rule):

• Bootstrap a company from zero (UC1; end with /pc-cost-safe).
• Hire an agent (UC3; cost-safe adapter by default; a hire approval STOPs → /pc-approve).
• Hand off work (UC4; pull by default, wake only on cost-safe external bridged/webhook or process agents).
• Monitor — dashboard + live runs + cost + approvals in one read (UC6).
• Recover stalled work — the references/recovery.md ordered protocol.
• Routines — references/routines.md; never a claude_local target.
• Secrets — references/secrets.md; metadata only, values never move.
• Restructure goals/projects/company — operator-only; strategic changes from the loop go through an approve_ceo_strategy approval, never auto-applied.

6. Hard rules

• Idempotency / run-id on retryable wakes. Send X-Paperclip-Run-Id on checkout, release, interactions, and on PATCH of an in_progress issue.
• One agent per issue. Orchestration is the primary guard; the 409 checkout conflict is the backstop — a 409 means another agent owns it: STOP, never retry.
• Never set in_review without a real review path. Dispositions are done / in_progress / blocked; the API returns 422 for a phantom in_review.
• Destructive commands need confirmation. No silent destructive action.
• Post cost events after local work so the company's spend ledger stays accurate.
• Secrets boundary. The API never returns secret values. Embodiment uses local credentials; a managed-only secret the founder lacks locally is a first-class blocker — set the issue blocked (name the credential) and notify the founder. Never fabricate a credential. See references/secrets.md.

References (progressive disclosure — load on demand)

The deep CLI reference is the companion paperclip-cli skill — installed separately (canonically at ~/.claude/skills/paperclip-cli; gated by scripts/ensure-skill.sh, which every entry command runs and stops on). Its SKILL.md + references cover the full paperclipai surface (golden rules, exact flags, --json output shapes, per-family gotchas) and are the authoritative source for command syntax — prefer them over this skill's hand-maintained snapshot files whenever you need exact flags or output shapes.

These files live in references/ next to this skill. Load the one you need:

• references/embodiment-loop.md — the standalone heartbeat embodiment loop in detail, with exact endpoints.
• references/operator-runbook.md — bootstrap / hire / handoff / monitor / recover sequences.
• references/cost-safe-mode.md — the cost-safe config contract verbatim plus the heartbeat-policy levers.
• references/api-contract.md — the API contract (Appendix A), verbatim. The authoritative source for any exact endpoint.
• references/routines.md — operating Paperclip routines: the two scheduling layers, the no-claude_local-target rule, and the routine endpoints.
• references/secrets.md — the secrets boundary: the API never returns values, embodiment uses local credentials, managed-only secrets are a blocker.
• references/recovery.md — the triage / recovery protocol.
• references/guardrails.md — budgets, approvals, and the cost guard.