The engine pane
When an agent does something unexpected, the answer is usually not in what it said. It is in what it was given. The agent did the right thing with the wrong information.
This is that information — the exact document the model received.
One page per call
Every engine call emits three events: the model it opened with, the messages it committed, and the response that came back. The pane correlates them into one page.
The pager — 3 / 3 above the document — steps through the run's calls, and the slider beside it scrubs a long run quickly. One page is one thing the model was asked.
Nothing is reconstructed. These are the messages the runtime committed, in render order — not a replay assembled from thread entries. A call still in flight shows its input with no output yet, rather than a guess at one.
Reading the document
Context is rendered as AIR, which is tag-structured, so the pane slices it by section:
| meta | Who the agent is, where it is, what time it is |
| scope | The tools available on this call |
| system | Its identity and instructions |
| contract | The output shape it must produce |
| timeline | Everything that has happened so far |
Most context bugs are visible immediately. A tool the agent never called was never in
scope. An instruction it ignored was never in system. Those two account for most of
the time people spend guessing at prompt problems.
Switching sections keeps your place in the run, so you can hold one section open and page
through every call watching only that part change. Watching timeline grow is the
fastest way to find where context went bad.
The response, unparsed
OUTPUT, below the document: what came back, before the runtime parsed it. On a
structured run that is the raw <template>…</template><done/> the agent emitted, not the
message the conversation ended up showing.
Two fields there are worth reading every time. stopReason: length means the model
was cut off mid-thought and everything downstream is working from a truncated answer.
Attempts above one means the call failed and was retried — invisible in the final
output, and often why a run took far longer than it should have.
Why this pane matters
The rest of the console tells you what happened. This tells you what the agent knew when it decided.
Prompts, tools, modules, memory, policy — every part of building an agent resolves to one question: did the model see what I think it saw? This is the only view that answers it.
Next: I/O — for an agent whose input is not a conversation, what it was receiving while it decided.