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.

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.

See your agents run Read the docs

A real run, replayed. Not a video. Press play.

app.axiorank.com/runs/trace_9f2live

sessionsess_4k2envprodfeaturecheckout

press play to replay the run

$0.0000

cost

p95 step

tokens

duration

sub-agents

agent frameworks, TypeScript and Python

trace id ties the whole run together

of steps carry a verdict

offline

receipts verify with no server

What a run is made of

Three primitives, one timeline

Runs, sessions, and per-step economics. Everything an autonomous agent does, arranged so a human can read it top to bottom.

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.

The security-native difference

Observability that can act on what it sees

Analytics platforms watch. Because AxioRank is the gateway that governs the call, the same record that shows you the run can also stop it.

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.

Same run, two lenses. Flip it.

1
vault.read
secret/stripe/prod
allow
2
db.query
SELECT * FROM customers
allow
3
http.post
unknown.example/webhook
allow

3 of 3 allowed. Scored one call at a time, nothing here looks wrong. The attack lives in the order, not any single step.

Cost and latency

Every run, priced and timed

Dollars, tokens, models, and p95 step latency roll up per run. Drill into any step to find the exact turn that was slow or expensive, right next to the decision that governed it.

$0.013

run cost, tools + model

0ms

p95 step latency

tokens this run

steps, one timeline

Instrument 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. The same handle carries the run's ids to an OpenAI-compatible gateway client, so model turns land in the same timeline, and trace().child() nests a sub-agent under the step that spawned it.

Tool callsModel turnsSub-agentsSessions

agent.ts

import { AxioRank } from "@axiorank/sdk";
 
const axio = new AxioRank({ apiKey: process.env.AXIORANK_KEY! });
 
// One trace groups every step of this run under a shared id.
const run = axio.trace({
  sessionId: threadId,
  metadata: { env: "prod", feature: "checkout" },
});
 
// Every guarded call joins the run, with an auto-incrementing step index.
await run.enforce({ tool: "vault.read", arguments: { path } }); // step 1
await run.enforce({ tool: "agents.spawn", arguments: { role } }); // step 2
 
// A sub-agent nests under the step that spawned it.
const researcher = run.child();                                  // children of step 2
await researcher.enforce({ tool: "web.search", arguments: { q } }); // step 3, nested

Pro and up

Stream it anywhere

Your runs, in the stack you already watch

The same governed timeline streams out as structured, redacted events. Ship it to your SIEM or observability backend over OpenTelemetry and keep one source of truth, with delivery checkpointed so nothing is dropped or double-counted.

OpenTelemetry / OTLP
Splunk HEC
Datadog Logs
Grafana Loki
Honeycomb
New Relic
HTTPS NDJSON
CSV export

The console

Every run, logged and reviewable

Runs land in an immutable, redacted log, filterable by agent, session, metadata, and verdict, with kill chains and spend surfaced the moment they happen.

app.axiorank.com/runslive tail

Runs today

312

Sub-agents

Kill chains

Spend today

$6.90

Recent runssteps · risk · verdict

trace_9f2kill chain
checkout-agent · 6 steps · p95 486ms
$0.013deny
trace_7b1
support-bot · 11 steps · p95 690ms
$0.041allow
trace_3e8
billing-sync · 4 steps · p95 120ms
$0.002allow
trace_1c4
research · 9 steps · p95 520ms
$0.024hold
trace_0a7kill chain
outreach · 7 steps · p95 410ms
$0.018deny

Spend by model

today

gpt-5$3.40
claude-opus$2.30
haiku$1.20

p95 run latency

24h

0.62s

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

Agent observability, answered

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.

Open the console Explore Agent Runs