Inside the ACP Console: My Own Agents, Real Data, Every Screen
The hardest thing to explain about a control plane is what you actually see once your agents run through it. A feature list doesn’t land it. So instead of describing the console, I’m going to show you mine — my real workspace, the agents behind Calafia, running in production. Every number below is real, pulled straight from the dashboard. Nothing staged.
Four screens: see every action, control every action, price every action.
1. Every agent, every call — one view
This is the first thing I open. In the last 7 days: 19,662 governed tool calls across 28 agents, $784.63 of model spend, 140 calls denied, 165 errors, 121 PII redactions — each with a little trend line. Below that, the run distributions: every run as one dot, cost-per-run and runtime-per-run, with the long-tail outliers pulled into a gutter so the typical range stays readable.
That’s the black box, turned into a dashboard. Before ACP, “what did all my agents do today, and what did it cost” was a question I couldn’t answer without grepping logs across services. Now it’s the landing page. The denied and PII-redacted counters are control working — quietly — and the distribution plot at the top (one dot per run) is the tell that agents don’t behave like normal software.
2. The same agent is never the same twice
Click any agent and you get its distribution across runs. This is Claude Code over a week: a median run costs $18.59 — but runs range from under 1¢ to $501.61, a coefficient of variation of 172%, flagged erratic. Same agent, wildly different cost run to run, because each run does different work and the loop re-reads a different amount of context each time.
This is the thing traditional observability misses: an agent isn’t a function with a fixed cost, it’s a distribution. If you’re watching the average, you’re blind to the tail — the $501 run hiding behind an $18 median, or the one that quietly stalls. ACP shows the whole spread — cost, runtime, model calls, tool calls — per agent.
3. Where the money actually goes
This is the screen I built ACP for. Open a single run and it decomposes the bill loop vs. leaf.
This run cost 0.390¢, and 99% of it was the orchestration loop — the model re-reading its own growing transcript to decide what to do next — not the actual work. The leaf tools (web search, memory lookup, sending an email) were free. The per-step table names the culprit; “context growth” charts the transcript ballooning to 59.3k tokens by the end; and What to optimize spells out the move: prune context between turns, use fewer and better-specced tools so the loop takes fewer turns.
I call this the loop tax, and almost nobody measures it, because measuring it requires being both in the call path and pricing every call in dollars. Observability tools watch but don’t price the enforcement point; gateways price tokens but don’t decompose the run. ACP is one layer, so the governed call and the metered call are the same event — which is the only way you get this view.
4. And the control
Seeing is half of it. Here’s the other half — per agent, every declared tool — captured from the agent’s own requests before anything runs — is a row with allow, flag, or deny one click away, enforced at the call itself, outside the model. This one runs in the background tier. I can deny notifications.sendEmail or any destructive tool and it’s blocked no matter what the model decides to do — a poisoned web page can’t talk it into an exception, because the rule doesn’t live in the prompt.
Every workspace starts in audit mode: watch everything, block nothing. When you’ve seen enough, you flip to enforce. No big-bang policy migration, no rewriting your agents.
None of this is trapped in the UI
One thing that matters more than any single screen: everything you just saw is an API, not just a dashboard. Every call, every run’s loop-vs-leaf cost breakdown, every agent’s distribution — it’s all available as JSON. The console is just one renderer of it; your own tooling can be another. GET /api/v1/runs returns the same per-step cost decomposition you saw in the X-ray; the activity log, the agent rollups, the policy decisions — all of it queryable and exportable (JSON, CSV, webhook).
Pipe it into your SIEM, your warehouse, a Grafana board, a weekly cost digest in Slack — whatever you want. A control plane that locks your own agents’ data inside its UI isn’t a control plane, it’s a roach motel. Yours comes with you. (API docs →)
That’s the whole thing, in four screens
See every action, control every action, price every action — for whatever agents you’re already running, across whatever framework. It’s the same console you just looked at; the only difference is the data would be yours.
It’s free on your own agents — 10,000 calls a month, no card:
curl -sf https://agenticcontrolplane.com/install.sh | bash
One command, about 30 seconds to your first governed call. Or if you’d rather not do it alone, book 30 minutes and I’ll wire it into your agent with you, live. Poke around, break it, tell me what’s missing.
— David
Start free → · Pricing → · How the loop tax works →