Glossary
Names in Axle are load-bearing — they show up in event types, span names, option names, and your own code. So these definitions are normative: if a page on this site contradicts one, the page is wrong and we'd like to know.
If you're meeting these for the first time, Anatomy of a send walks through them properly. This page is the quick-reference version.
The three strata
| Layer | Unit | Contains | Lives at |
|---|---|---|---|
| Wire | Message | content parts | agent.messages |
| Execution | Step | one request + its fallout | the send() loop |
| Render | Turn | parts (+ annotations) | the host's Transcript |
One send() = one or more steps, producing one user turn and one agent turn, carried on the wire as messages.
Terms
Message — the wire-layer unit: a role-tagged (user / assistant / tool) AxleMessage whose content is a list of parts. Messages are what providers consume and what compaction rewrites. Never render state; never host-level chat input.
Part — the atomic content unit: text, thinking, tool-call, file, citation. Parts are the shared vocabulary of the wire layer (AxleMessage.content) and the render layer (Turn.parts) — the same concept at both. A subagent invocation is a tool-call part like any other.
Step — one pass of the execution loop inside a send(): one provider request, the assistant message it yields, and the tool batch that message requests, if any. A send ends with the first step whose message requests no tools, or when a budget (maxSteps, maxContextTokens) or a boundary control stops the loop. Steps are invisible in conversation state — each step's output is flattened into messages and into the agent turn's parts. Spans are named step-N; stream events are step:start / step:complete.
Turn — the render-layer unit only: one conversation entry in a transcript, a user turn or an agent turn. One send produces one of each; the agent turn accumulates parts from every step. Turns can also be opened and closed by compaction. Never a single assistant message; never a provider request.
Send — the Agent API verb: one scheduled conversation exchange (agent.send(...)), executed as a FIFO queue item. The host-facing unit of "the agent took its turn."
Display — the request-side reasoning disclosure control: display: "visible" | "hidden" on the { effort } form of reasoning. It says whether the provider should show its thinking, never in what form. The form that arrives — a summary or raw text — is recorded on the thinking part and is the model's property. "hidden" withholds thinking content from the turn while the message keeps whatever the wire carried, so continuity still round-trips.
Summary / raw — the two content fields of a turn's thinking part, each named for what the provider handed back: summary is the provider's condensed account of its reasoning, raw is the chain of thought itself (open-weight models only). Neither present is the withheld state. The message-layer thinking part keeps the wire vocabulary (text, summary, redacted) because it exists to be echoed, not read.
Redacted — a wire-layer flag only: the provider substituted an opaque payload for the content and wants it echoed on the next turn. Never a turn-part or event field, and never set because thinking was merely hidden.
Transcript — the host-owned, reader-facing fold of TurnEvents into turns and annotations. The exported Transcript class is the shipped in-memory implementation; hosts persist its turns and pass them to the constructor on restore. The Agent holds no transcript — it emits events and keeps only the active messages. Lose the turns, lose the transcript.
Session — the continuable identity of a conversation (sessionId). AgentSession is its serialized form: the pure continuation { sessionId, messages } that agent.snapshot() captures and the Agent constructor restores. The transcript is not part of it.
Compaction — replacing the active conversation with a condensed rewrite, recorded on the transcript as a compaction turn part. Old messages cease to exist; lookback is served by the transcript.
Trace — observability only: the span tree produced by the tracer and consumed by span writers. Never the conversation transcript.
Annotation — host-owned render state attached to a turn or a part. Never model state, never sent to a provider.
Tool — an executable capability. Four sources: local ExecutableTools, provider-managed tools, MCP tools, and subagents. All share one ToolRegistry and one flat namespace.
Renamed terms
| Was | Is | Since |
|---|---|---|
| turn (execution loop) | step | 0.29.0 |
maxIterations | maxSteps | 0.29.0 |
"max-iterations" | "max-steps" | 0.29.0 |
generateTurn | generateStep | 0.29.0 |
TurnAccumulator | Transcript | 0.30.0 |
agent.history.log | agent.messages | 0.26.0 / 0.30.0 |
ThinkingPart.text | ThinkingPart.summary / ThinkingPart.raw | 0.32.0 |
ThinkingPart.redacted (turn) | removed — redacted is wire-layer only | 0.32.0 |
thinking:delta (stream and turn) | thinking:raw-delta | 0.32.0 |
generateStep | removed — use stream() with maxSteps: 1 | 0.32.0 |
Models / ModelInfo / ModelMetadata (@fifthrevision/axle/models) | removed — pass model IDs as plain strings | 0.33.0 |
temperature / topP / stop (request options) | removed — send through providerOptions with provider field names | 0.33.0 |
AxleFailure { kind: "tool" } | removed — nothing produced it | 0.33.0 |
AxleFailure nested error (ModelError, parse error) | flattened — model carries type/status/usage/raw directly; parse carries cause | 0.33.0 |
provider-tool part output | input / result / continuity; results in continuity, late results in provider-tool-result parts | 0.33.0 |
provider-tool:complete output (search) | search results live on the part's continuity; failures arrive as provider-tool:error | 0.33.0 |
AxleStopReason.Error / AxleStopReason.Custom | removed — unknown stop reasons fail the request | 0.33.0 |
See Upgrading.