I ran my AI agents on a real control plane — not on vibes.
Every task routed by agent identity. Every “done” gated by QC. Every action written to an audit trail. Issue triage tracked as HOL-### tickets across a fleet of agents. When the plane broke — a P0 auth outage, a gateway regression that failed 658 runs in a day — I diagnosed it, directed the fix, and hardened it so it couldn’t happen the same way twice.
Chat is a terrible system of record for a workforce.
I didn’t run my agents on chat messages and hope.
A fleet of autonomous agents across three Mac minis needs ownership, status, and a way to tell “said” from “done” — none of which a chat log gives you.
Chat is fine for a conversation. It’s a terrible control surface for a workforce: no ownership, no status, no verification, no audit.
I needed a control plane where work was assigned, tracked, verified, and auditable — so agents couldn’t self-close tasks, stale docs couldn’t override live truth, and I could see exactly what each agent was responsible for at any moment.
Slack coordinates. The control plane executes and owns.
One explicit operating model: Slack for decisions and coordination; the control plane for execution, ownership, status, verification, and audit trail.
Every unit of work became an HOL-### issue with an owner, a status, and a comment thread that served as the audit log. Agents polled their own queues by identity — a poll returned that agent’s tasks and nothing else — and the system was wired into the agent gateway so heartbeats and wake cycles flowed through it.
I drafted a company-wide governance model to enforce what makes a control plane trustworthy: verify-before-done, no self-close, a QC chain, blocked-status discipline, and live-truth-over-stale-docs. I supervised through the board — grouping work into projects, triaging blockers, and directing root-cause and remediation when the plane itself failed.
I operated, integrated, and governed this control plane. The agents executed the work; I was the operator and the accountable owner — that's the honest framing, not "I wrote the software."
— Attribution note · operated, not authoredThe control-plane topology.
Slack carries decisions. The control plane owns execution, status, QC, and the audit trail. It routes work to the agent fleet by identity through the gateway, and every action is written back as an issue comment. I supervise the board.
Slack carries decisions; the Paperclip control plane owns execution, status, the QC gate, and the audit trail, holding work as HOL-### issues with per-agent poll keys. It routes tasks by identity through the gateway to the fleet, and every action is written back as an issue comment audit trail. The operator supervises the board as the accountable owner. Exposed through an internal, auth-gated dashboard behind a Cloudflare tunnel.
Control Plane
Agent Runtime
Integration
Coordination I/O
Governance
Ops / RBAC
How an HOL-### issue moves.
Every unit of work is an owned issue with a real status and a comment thread as its audit log. Completion is gated — an agent can’t mark its own work done.
Routing proven; incidents run like an operator.
Verified from the internal record — counts, incident scope, and remediation. Operational facts, not performance benchmarks.
Two incidents, root-caused and hardened.
The value isn’t that it never broke — it’s how it was run when it did: root cause, committed fix, then hardening so the failure mode was closed, not just cleared.
Operated and governed — not authored. Iterated, not finished.
Paperclip is a real system I operated, integrated, and governed — the record shows configuration, RBAC, incident fixes, and process management, not that I wrote the tool from scratch. The QC chain was an enforced model, not a fully automated guarantee. The board accumulated blocked routine items and duplicates that needed periodic cleanup, so this was iterated, not “done.”
No cost tracking is claimed. There is no evidence Paperclip tracked spend, and this page makes no such claim — only what the record supports.
I owned the control plane.
I set the operating model, defined the governance rules, structured the work, controlled RBAC, and ran triage.
Slack coordinates; the control plane executes, owns, and audits. I defined verify-before-done, no self-close, the QC chain, the audit trail, and blocked discipline. I structured work into projects and HOL-### issues, controlled agent RBAC and assignments, and when the plane failed I directed the diagnosis and remediation and required the fixes be hardened and committed. The agents executed; I was the operator and the accountable owner.