Agent observability has mostly meant one thing so far: a nicer place to read a trace.
That made sense a year ago. A model call going sideways was new, and seeing the prompt next to the response felt like progress. But the industry has treated seeing the failure as the finish line. The trace shows you the refund agent broke. Then a human opens a ticket, reads the prompt, guesses at a change, edits it, ships it, and waits to find out whether the same failure comes back.
Observability exists to shorten the distance between a problem and its fix. For agents, that distance is still a ticket.
A trace is where the investigation starts
Take a refund agent. A customer asks for their money back, the agent calls a tool, and the tool call fails. Your trace viewer paints a red span. Good. Now answer the question you actually care about: why?
The agent's trace can't tell you. The answer sits in the Payments API's application log, which recorded a rejection. Behind that rejection is a security event: an expired credential. Three systems, one story, and the only thing connecting them is whoever is on call and happens to know where to look.
So most teams end up with half an answer. They know the agent failed. They don't know why, and they have no way to check whether the change they're about to ship fixes it.
Introducing CtrlB AI Observability
Today we're opening CtrlB AI Observability, and it's live.
It traces your agent runs, finds the failures, and tests changes to your prompts and skills against real production examples. Your team reviews the results and approves the update before anything is released. That last sentence matters more than the first two, and we'll come back to it.
One loop, five steps
Production runs come in. CtrlB flags failed checks automatically. It proposes a change to a skill. It compares the current version and the candidate against the same criteria. Then the change waits for your team. Once it ships, the new version goes back into production runs and the whole thing starts again.

When a candidate fails its checks, it goes back to Improve instead of forward to you. When it passes, it still sits there. In our example, evaluation passes and nothing is approved or released until the team acts. That is the design.
A system that fixes your agent and ships the fix without asking is just a second incident.
Follow the failure past the agent
Failed tool calls in CtrlB can be followed into application logs and security events. In the refund example, you start at the failed call, land on the Payments API rejection in the application log, and find the expired-credential security event behind it. The conclusion writes itself: the expired credential blocked the refund.
No prompt edit would have fixed that. This is exactly why an agent-only view sends teams down the wrong road. They rewrite instructions for a problem that lives in a credential store.

One honest requirement. The related records need a shared identifier captured in both systems, such as an order ID or a payment request ID. Without one, nothing can join them honestly. We'd rather say that here than have you find out halfway through a demo.
Does the fix actually fix it?
Any production example can be saved as a test. After that, the current version and the proposed one run against the same criteria, and you see both results side by side.
Our example is a small, embarrassing one. A customer got the same email twice. A send call timed out after delivery, and the duplicate followed. The candidate version sends one email instead of two. That is the whole story, and it is the kind of change you want to see proven before it goes near a release.

Evaluations run on your own model key, and the cost of each run is visible. You can see what the checking costs before you ask it to check more.
Policies that apply while the agent is running
Everything so far happens after the fact. Guardrails happen before. Tool calls are checked before they execute, and a policy can block a prohibited action, require approval for it, or mask sensitive data in a tool result before the agent ever sees it.
Guardrails work with Claude Code, the OpenAI Agents SDK, LangChain, Google ADK, and FastMCP.

Relay: when one agent isn't enough
CtrlB Relay is a shared-context layer for agents that have to work together. A triage agent, an infra agent, and an eval agent share findings, claims, handoffs, and results through an event ledger, and they work toward one goal instead of three separate ones. Think of the shared incident channel, except every message is structured and every handoff is recorded.

Your data stays in your bucket
Agent, application, and security data are stored together in your own object storage, as open Parquet files in S3, GCS, or Azure Blob. You can read them without CtrlB. If you ever stop using us, the files are still there and still readable.
Getting data in takes whatever you already run:
- OpenTelemetry SDK
- Langfuse SDK
- OTel Collector
- OTLP exporters
Spans that follow the GenAI conventions show up as agent, model, and tool calls without any manual mapping. On the way out you get an AI Traces view, evaluations and findings, SQL access, and an MCP server with search_traces, fetch_trace, and run_sql tools, so agents can query traces directly.

CtrlB is SOC 2 Type II, supports SSO and RBAC, and is available on AWS Marketplace.
Pricing
AI Observability is live. Pricing starts with a flat platform fee, and usage is quoted on top.
$499 / month platform fee. Usage is quoted separately for your workload. Model and bucket costs are billed to you directly by your providers.
- Production traces
- Model cost tracking
- Scheduled investigations
- Prompt comparisons
- Tool policies with Guardrails
- OpenTelemetry support with your own bucket and model key
Enterprise pricing is available for larger deployments. Trace volume, evaluation usage, and guardrail checks are quoted before you start. Agent tracing and cost tracking also work on their own, without the other capabilities.
Where this goes
For a while, agent observability competed on how clearly it could show you a failure. Showing was never the hard part. Our bet is that the next useful thing is a fix that has already been tested, sitting in front of the person who decides whether it ships.
A failed run should end in a tested change, not a ticket.
Bring a failed run to the demo. Live now, from $499/month plus usage. Book a demo
