A strong agent session feels like progress. It drafts the PR, sketches the plan, even names the risk. Then the tab closes — and the company still has no record of who decided what, what started, or what is still waiting on a human.

That gap is the same one we named in Claude as EA/CoS: the litmus test: sessions are not systems of record. An operating system for agent work needs desks, a wake path, an approvals inbox, and delivery that does not invent autonomy.

Cockpit is that control plane for how we run CloudBeast. The buyer we are writing for is a small US consulting company — a principal or managing partner, typically 2–25 people — who still sells hours and already pays the Salesforce / Asana / marketing / keys / wiki tax. This draft is not a product launch announcement. It is the architecture we already use — agents, desks, approvals, hooks, delivery — written so that shop can sell a completed outcome instead of another retainer line.

What "OS" means here

Skip the metaphor inflation. For agent-native ops, an OS is five boring surfaces that stay honest under load:

1. Desks — named work lanes with owners, not a shared chat scrollback.
2. Todos — the only wake signal. No todo, no run.
3. Runtimes — bound executors (Cursor Automation and kin) that claim work; they do not self-cron the company.
4. Approvals — Joe's sole verdict inbox. Propose in chat; dispose in Cockpit.
5. Delivery — PRs, artifacts, and close requests attached to the task — not free-floating agent dumps.

Git holds the durable content graph. The database mirrors runtime and work state. Cockpit is where verdicts land. That split is intentional: content compounds in git; decisions compound in the approvals table; agents do not get to "just ship" because the prose sounded confident.

The public feature list lives on Cockpit. What follows is how those surfaces help a human operator — the same loop we run after a real call.

The stack it replaces

Small US consultancies already pay for this pile — or they were about to buy HubSpot as the suite. Salesforce, marketing automation, Asana, n8n for keys, a wiki nobody searches.

Cockpit is that stack, collapsed. Full suite — CRM, desks, marketing, Vault, knowledge — better than HubSpot for agent work you can sell. Not another seat.

The move is two steps. Buy the AI. Use it for everything in your own shop (~$300–500/mo — cheap, easy). Then help others implement. We got your back. Cockpit stays $0 until that outcome sells.

No other system lets you fully automate the work and sell the agentic outcomes. Chat automates a session. A CRM stores a record. A project tool stores a task. None of them close the loop: work completes in the system → marketing learns from that completed work → you sell the outcome. That is the product. You do not invent a case study. You sell what already finished.

What it costs to run (and why Cockpit is $0)

Easy $300–500 a month to buy the AI (typical vendor band — not our invoice). List prices checked 2026-09-05. Usage can go over. Cheap next to HubSpot + the pile.

Line	List	Why it is on the bill
Vercel	$20/user/mo Pro + usage	Commercial host. Pro includes $20 credit; extra is pay-as-you-go. (pricing)
Supabase	$10 Micro compute min · Pro from $25/org	$10 is the compute floor. Pro includes a $10 credit that covers one Micro. (pricing)
Google Workspace	from $7/user/mo Starter (annual)	Mail, calendar, Drive — what the agents ingest.
Claude Teams	$25/seat/mo Standard ($20 annual)	Min 2 seats. Premium $125/mo for heavy Claude Code.
Cursor Ultra	$200/mo	Agent power plan. Includes Grok Bot access.
Grok bots	SuperGrok from $30/mo · API extra	Bots + production API. Do not double-count if Ultra already covers Grok Bot.
Cockpit	$0	Until you sell a completed outcome to a customer.

We charge $0 for Cockpit until that outcome sells because the stack cost should be visible, and billing + project management should live in the same system the work ran in. A seat tax before the first sale hides the economics. After a sale, the customer can see what ran, what it cost, and what closed. We get paid when you do.

How it helps a human like me

The job is not "use more AI." The job is: hang up, keep the names, start the work, and still be the person who said yes. A solo operator can go call → prototype in hours when the stack does the matching and the drafting — and you keep start and close.

Meetings that survive bad spelling. Transcripts miss names. Ingestion runs entity match search, then you confirm the person or company before the CRM sticks. That is the difference between a useful follow-up and a duplicate contact you will clean for a month.

Approvals — all the types that actually show up. One inbox. Promote a task (approve is the start). Close a task (the agent does not self-declare done). Create, update, rename, merge, or link people and companies. Mint a project. Gate an outbound draft or X reply. Turn a scorecard or rec into work only when you say so. Policy cards that record a verdict and run nothing. Chat proposes. You dispose.

Integrations tab. Google, X, and the rest in one account page. Connect once. Tokens sit in Vault — not in a laptop .env you will lose on the next machine.

Any agent runtime you already pay for. Bind Cursor Automation, Claude, or Grok to a desk. Cockpit owns the schedule. The agent does not invent its own cron. Claude CCMA is the next runtime row on that same tab — coming soon, not live.

MCP with PATs and profiles. Scoped keys so Claude or Cursor can talk to the CRM without holding the whole company. Permission profiles are how you give an agent a job, not a skeleton key.

Logs tied to the work. Hooks stamp the live session on the work item so you can see what ran against a project milestone. The full execution-log drain is still landing — the point of the design is already this: not a folder of transcripts.

Automated marketing. The engine that writes the site and schedules X runs from a Marketing desk. It learns from work already completed in Cockpit — closed tasks, shipped PRs, desk outcomes — and that is what you sell. You see the run on Cockpit. You do not live in Slack as the approval inbox.

SDR that drafts. Research, qualify, draft replies. Outbound stays draft-and-hold. No silent send.

Desks and projects as the org chart. Marketing, meetings, ops, SDR — each desk has routines and a human promote/close loop. Work is not a shared chat scrollback.

Streaming Cursor Cloud UI — watch a run without leaving the desk. In progress. We will not sell it as shipped.

Multi-repo runtimes. Agents check in against the repos that hold the company, so enterprise knowledge stays on. The handoff we want next: when we leave, the client keeps an embedded agent — not a slide deck and a goodbye. That embed is direction, not a SKU today.

The gate is the product

Most agent demos optimize for fewer clicks. We optimize for the right click.

Task promotion is never automatic. A proposal can sit in backlog until a human approves it. On the shapes that matter, that approve is not a sticky note — the row carries an on_approve action (for example: move this task backlog → todo). The click is the start signal. The runtime claims the work. The close of the task stays a separate human gate.

We learned the hard way that an approval without an executable action is theater. Cards that approve and do nothing teach the wrong lesson: "I clicked, so it must be running." Prefer shapes where approve does something allow-listed — status move, enqueue — and where reject/defer never fires the side effect.

That is the same decision-boundary discipline as the EA/CoS litmus: capture thresholds and exception rules at the decision point. The exhaust (who approved, what started, what closed) is what makes the next run better. Silent autonomy starves that loop.

One real loop (ours, not an invented case study)

Here is a loop we actually ran — described at architecture level, not as a customer story:

1. A desk todo is minted with an explicit runtime assignment and an on_approve that flips the task into todo.
2. Joe approves in Cockpit. The action fires; the task leaves backlog.
3. Within about a minute, the bound Cursor runtime claims the work item.
4. It opens a PR, pushes the change, and leaves the task in review — not auto-done.
5. Close still waits on a human. Merge and "work finished" are not the same button.

That is the product thesis in one cycle: approve to start, human to close, delivery attached to the task. Cross-desk asks follow the same spine — who approves can differ from who executes — without turning chat into a shadow project manager.

We do not claim this as a published multi-customer Cockpit case study. Client work like LeverEdge and Klabin proves we ship production systems; it does not prove Cockpit desks. Keep those stories in their own posts. This one is about the control plane.

Architecture lessons that travel

• Decide, execute, and steer are different planes. Approvals, tasks, and comments must not collapse into one blob, or you cannot audit any of them.
• Chat proposes; Cockpit disposes. Launchers and sessions can read and propose. Every consequential action still becomes a card a human swipes.
• Cockpit owns the schedule. Heartbeats and ticks mint or wake work; runtimes are webhook-driven. Agents that invent their own cron invent their own company.
• Pickup is the envelope. /desk-pickup (and its cousins) claim the dispatched unit, read handoff comments, then run the routine — not a scavenger hunt across every open todo.
• Draft-and-hold beats fake autonomy. Outbound, merges that need judgment, and publish gates stay human until the boundary is written down and measured.

If your stack cannot answer "what started because I approved, and what is still waiting on me," you do not have an agent OS yet. You have a demo laptop with better autocomplete.

What this is not

• Not a chatbot wrapper. A model in a tab is a session. Desks + approvals + delivery are the OS.
• Not "set and forget" autonomy. Close stays gated. Broken on_approve shapes fail closed or no-op — we treat that as a defect, not a vibe.
• Not an open-source drop today. Open-sourcing Cockpit is a direction we care about; this draft markets the operating truth we run, not a repo that is already public. When the code is ready to share, the story should still match this architecture — or the story was the lie.
• Not "keep your five tools and add a dashboard." Cockpit replaces Salesforce-class CRM, marketing automation, Asana-class project/task boards, n8n-as-the-integration-and-key-store, and the knowledge base. Slack and calendars can still be channels. They are not the system of work, and they are not what you sell from.

Soft next step

If your team is drowning in impressive sessions and starving for durable decisions, start with one owned loop: one desk, one approval shape that actually starts work, one close gate that teaches the system.

Book a free Quick Assessment at cloudbeast.io/schedule. If you already know the process and need a scoped build plan, the Tier 1 AI Audit ($999) is at cloudbeast.io/audit. Prefer community? Bring the scorecard, not the tool wishlist, to Slack.