---
title: "Announcing CtrlB AI Observability"
description: "Introducing CtrlB AI Observability: trace agent runs, find the failures, and test the fix before anyone ships it. Live now."
canonical: "https://ctrlb.ai/blogs/announcing-ai-observability"
publishedTime: "2026-11-13"
modifiedTime: "2026-11-16T13:26:46+0000"
author: "Adarsh Srivastava"
tags: []
---

# Announcing CtrlB AI Observability

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.

![Five-step loop: production runs, detect, improve, evaluate, team review, with runtime guardrails underneath](https://images.prismic.io/ctrlb-new/_yjbkLIw9-JcZrNY_loop.png?auto=format,compress)

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.

![The refund agent's failed tool call, the Payments API rejection in the application log, and the expired credential in security events, joined by a shared payment request ID](https://images.prismic.io/ctrlb-new/w2V5HhJ6GcVkGsNc_rootcause.png?auto=format,compress)

**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.

![A duplicate-email production failure saved as a test: the current version sends 2 emails and fails the check, the candidate sends 1 and passes](https://images.prismic.io/ctrlb-new/5VYHQWOTTzGrTipi_eval.png?auto=format,compress)

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.

![An agent tool call passes a policy check that can block or require approval, then the tool runs and sensitive data in the result is masked before the agent sees it](https://images.prismic.io/ctrlb-new/qf4OL9f-uLMI3qyz_guardrails-v2.png?auto=format,compress)

## 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.

![Triage, infra and eval agents share findings, claims, handoffs and results through an event ledger toward a shared goal](https://images.prismic.io/ctrlb-new/Vtzvb1PlKuEtcaNY_relay.png?auto=format,compress)

## 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.

![Telemetry from OpenTelemetry, Langfuse, collectors and OTLP exporters flows into CtrlB, which stores agent, application and security data as open Parquet in your own object storage, then serves traces, evaluations, an MCP server and SQL](https://images.prismic.io/ctrlb-new/lH73J4rWYDUum5Js_data-v2.png?auto=format,compress)

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](https://ctrlb.ai/contact)
