Understand runs, prompts, models, tools, policies, tokens, latency and behavior through an observability layer built for agentic systems.
Traditional monitoring tells you whether the infrastructure is healthy. Operating agents means understanding what the agent actually did: which path it took, which tool it called, which rule was evaluated and what it cost. A healthy server can be running an agent that gets things wrong.
Here the trace is not added instrumentation: every agent step already is the span, the event and the checkpoint. One step feeds the trace, the cost ledger, the trail and the memory.
Which agent ran, on which version and under which owner.
Every run from start to outcome, with the path it took.
The units of work inside a run, including subagents.
The exact prompt that was sent, not the template that produced it.
Which model responded, with which parameters and at what cost.
Which calls went out, with which arguments, and what came back.
Which rules were evaluated and which one blocked.
Consumption per run, agent, team and environment.
Where the time went, step by step, not just in total.
The outcome of the run, and whether it delivered what was asked.
Every pending wait, for a document, a callback or an approval, visible in the console. The wait nobody sees is the 3 a.m. incident.
Active runs, success rate, p99 and token spend per agent and per tenant. Telemetry tied to money, not just logs.
A sick agent shows up in its error rate and cost before it becomes an incident, with incidents and budget alerts next to the metrics.
Pending four-eyes requests are counted alongside the metrics. Governing is part of running the fleet.
The agent returned the right answer, and as far as traditional monitoring is concerned, all is well.
Along the way it ran the same search eleven times.
And escalated to an expensive model for a trivial task.
Seeing agents as agents means treating the run as the unit. That's where 'why was this so expensive?' gets an answer.