LLM Span Kinds - Atatus Docs

Each span in an LLM trace has a kind, which tells you what that step was doing. This page lists every kind you can see and what to expect on each one.

The kinds

Kind	What it represents	Where it comes from
`chat`	A single model call using a chat-style interface. The most common kind.	Every producer
`completion`	A single model call using a plain completion interface.	APM agents
`agent`	An autonomous unit that chooses its own next step.	Coding agents, APM agents
`tool`	One tool or function invocation.	Coding agents, APM agents
`chain`	A sequence of steps grouped together, such as a session or a whole agent run.	Coding agents, APM agents
`retriever`	A document or context retrieval step, as used in a RAG pipeline.	APM agents
`embedding`	An embedding call.	APM agents
`reranker`	A reranking step over retrieved results.	APM agents
`workflow`	A grouping you define in your own code.	APM agents
`task`	A single step inside a workflow you define.	APM agents
`guardrail`	A safety or policy check.	APM agents
`evaluator`	An evaluation step scoring a model’s output.	APM agents

Coding agents use chat, tool, and chain. The remaining kinds appear when your own application is instrumented, because they describe pipeline steps a coding assistant does not have.

What each kind carries

The kind determines which fields are populated, so a tool span never has token counts:

Kind	Fields you can rely on
`chat`	Model name, provider, prompt and completion tokens, cache read and write tokens, cost, and the prompt and response if content capture is on.
`tool`	Tool name, duration, success or failure, and the tool’s input and output subject to your capture settings.
`chain`	The grouping’s input and output, its duration, and the spans nested inside it.

Reading a coding agent trace

Most coding agents produce a two-level tree, where the turn is the model call:

Turn 3                     chat    model, tokens, cost
├── Read                   tool
├── Edit                   tool
└── Bash                   tool    failed, error status

Antigravity, Devin, opencode and omp separate the model call from the turn, which adds a level:

Turn                            chain   prompt in, final answer out
├── LLM call 1: claude-opus-5   chat    model, tokens, cost
│   ├── Read                    tool
│   └── Bash                    tool
└── LLM call 2: claude-opus-5   chat    second model call in the loop
    └── Edit                    tool

This is why cost lives in different places depending on the tool. In a two-level trace it is on the turn. In a three-level trace it is on each LLM call span, and you add them up for the whole run. See Cost and tokens.

How a turn ended

Claude Code, Codex and GitHub Copilot record why each turn stopped in the turn.end_reason attribute on the root span. Claude Code uses all five values below. Codex and GitHub Copilot use completed and interrupted.

Value	Meaning	Span status
`completed`	The agent finished and wrote its final response.	OK
`interrupted`	You stopped the turn before it finished, for example by pressing escape.	OK
`continued`	You sent another message while the turn was running, so it was superseded.	OK
`abandoned`	The turn ended with no end-of-turn signal and no transcript to read.	Error
`failed`	The turn ended on a real failure.	Error

interrupted, continued and abandoned turns also carry turn.incomplete set to true.

Stopping or steering an agent mid-turn is normal usage, so an interrupted or continued turn is not counted as an error. An interrupted turn still carries the model calls, tool spans, tokens and cost that ran before you stopped it.

Reasoning effort

When a coding agent exposes a reasoning-effort setting, its model call spans carry it in llm.reasoning_effort as a lowercase level such as low, medium, high, xhigh or max. New levels are passed through as the agent reports them. Claude Code, Codex, Cursor, GitHub Copilot, Antigravity, opencode and omp report it. An agent that only says extended thinking is on, without naming a level, sets llm.thinking_enabled to true instead. Agents that do not expose the setting to their hooks carry neither attribute.

A span with no model name

Not every span in an LLM trace has a model. Tool and chain spans do not call a model at all, so they carry no model name, no tokens, and no cost. In a typical coding agent trace most spans are tools, so most spans have no model. This is expected. A trace where only the turns carry a model name is working correctly.

Next steps

Cost and tokens explains how spend is calculated.
Coding agents covers the tools that produce these spans.

​The kinds

​What each kind carries

​Reading a coding agent trace

​How a turn ended

​Reasoning effort

​A span with no model name

​Next steps

The kinds

What each kind carries

Reading a coding agent trace

How a turn ended

Reasoning effort

A span with no model name

Next steps