Agent observability
See every agent run. Prove every step was safe.
Your agents already act on their own: they call tools, spend tokens, and touch production. Agent observability turns that into one legible timeline per run, and AxioRank records it from the security gateway itself, so every step arrives with its decision, its cost, and signed proof it was governed.
Three primitives, one timeline
The run, not the log line
An agent does not do one thing; it does a sequence. A run groups every governed call that shares a trace id into one timeline: each tool call and model turn in order, with its decision, risk, latency, cost, and redacted payload. Sub-agents nest under the step that spawned them.
Sessions and metadata
A session groups the runs of one conversation, so a support thread that spawned three runs reads as one story. Metadata tags (environment, feature, your own request id) ride every call and are filterable, with values redacted at write so a tag can never store a secret.
Cost and latency, per run and per step
Every run rolls up what it cost in dollars and tokens, which models it used, how long it took, and its p95 step latency. Drill into a step to see the exact turn that was slow or expensive, next to the decision that governed it.
One trace id stitches everything
Start a trace in the SDK and every guarded tool call joins the run automatically, across 20+ agent frameworks in TypeScript and Python. The same handle emits gateway headers, so an OpenAI-compatible client pointed at the AI Gateway stitches its LLM turns into the same timeline. Spawn a sub-agent with trace().child() and its steps nest under the call that created it.
Observability that can act on what it sees
Verdicts inline, not alongside
Every step carries allow, deny, or hold with the policy that decided it, because the thing recording the run is the gateway that governed it. The run view doubles as the incident view: the step that was blocked is right there in sequence, with the signal that fired.
The sequence is the signal
Reading a secret is normal. Posting to an unknown webhook is normal. Doing both in one run is an exfiltration. Because runs are first-class, kill-chain detection fires on the pattern across steps, and cross-agent taint lineage links the runs that passed poisoned data between agents.
Evidence, not just analytics
Each step is sealed into a tamper-evident, RFC 6962 style audit log, and receipts verify offline with an open-source verifier. When someone asks what your agent did last Tuesday, you can hand them proof, not a dashboard screenshot.
Already running an LLM gateway? Keep it.
Routing gateways and LLM observability platforms are genuinely good at model routing, caching, prompt management, and request analytics. AxioRank is not trying to replace that layer; it governs the agent's actions and proves what happened. The two compose: keep routing model calls where you like, wrap your agent's tools with the AxioRank SDK, and send the trace headers through either path. We publish a fair, sourced comparison with Portkey that says exactly where each is stronger.
Questions
- What is AI agent observability?
- Agent observability is seeing what an autonomous AI agent actually did: every tool call and model call it made, in order, with the cost, tokens, and latency of each step. It differs from classic LLM observability because the unit of interest is the run, a multi-step sequence, rather than a single model request. Good agent observability answers three questions at once: what did the agent do, what did it cost, and was each step safe.
- How do I trace a run across tool calls and LLM calls?
- Thread one trace id through everything the run does. With the AxioRank SDK, axio.trace() returns a handle that stamps a shared trace id and an auto-incrementing step index on every guarded tool call, in TypeScript and Python, across 20+ agent frameworks. For the LLM turns, the same handle emits X-AxioRank-Trace-Id and X-AxioRank-Session-Id headers; set them on an OpenAI-compatible client pointed at the AxioRank AI Gateway and the model calls land in the same timeline as the tools they drove.
- Can I see sub-agents inside a run?
- Yes. When your agent spawns a sub-agent, trace().child() creates a handle that shares the run's trace id and step numbering while nesting every call under the spawning step, so the timeline renders a tree: the researcher sub-agent's searches indent under the step that created it. The child's gateway headers carry the same nesting for its model calls.
- How is this different from an LLM gateway's analytics?
- An LLM gateway or observability platform can tell you a call was slow, what it cost, and which model served it. It generally cannot decide allow, deny, or hold on the agent's tool calls, catch a multi-step attack spread across innocent-looking steps, or hand you cryptographic proof of what happened. AxioRank records the same telemetry from the security gateway itself, so every metric arrives with a verdict attached and every step with a receipt. Many teams run AxioRank next to a routing gateway they already like.
Your agents are already running. Start seeing their runs.
Runs, sessions, and kill-chain detection are free. Per-run cost and latency arrive with one line of SDK or one base URL swap, and every step comes with proof.