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 24 hours: 1,352 governed tool calls across 19 agents, 28¢ of model spend, 1 call denied, 4 errors, 22 PII redactions — each with a little trend line. Below that, the tool mix: Bash.cd, Read.src, llm.agent_run, apitools.webSearch, and so on, ranked by volume.
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 one averages 1.21¢ per run — but ranges from 0.39¢ to 2.17¢, a coefficient of variation of 42%, flagged variable. Same agent, same task, wildly different cost, run to run, because 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 an average, you’re blind to the tail — the 2.17¢ run that becomes a $40 run at scale, 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 tool is allow, ask, redact, or deny, enforced on the agent’s next run, 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 →