… an agent has taken on multi-step work—searching, reading, calling tools, or working through a problem—either inside a conversation or out of sight under delegation. A plan preview may have stated what the run intended beforehand and a working plan may track which steps remain, leaving the actual execution path still to be exposed.
Problem
When an agent reaches an answer through several steps, returning only the result leaves trusting it and doubting it equally uninformed. Yet dumping raw model monologue onto the surface buries the answer, invites actors to rely on plausible-looking text rather than check it, and blurs what the agent actually did with what it says it thought.
Four tensions govern the trail:
- Verifiable actions versus unverified narration: external tool calls and their outputs are checkable facts about what happened. Model chain-of-thought and thinking summaries are generated accounts that can omit hints, shortcuts, or biases that actually drove the result. Presenting both in the same voice lends the narration an authority it does not have.
- Legibility versus compression: collapsing raw thinking into milestone summaries reduces cognitive load, yet adds a second layer of omission over an already unfaithful account, stripping out the hesitation or dead end that would have warranted inspection.
- Persuasion versus verification: a fluent, step-by-step account makes an output look self-audited, raising overconfidence when reading the trail feels costlier than accepting the answer; flat text streams also make logical errors harder to spot than structured steps.
- Exposure versus privacy: a clean final answer does not guarantee a clean trail—internal reasoning and raw tool returns can resurface credentials, personal data, or system instructions that the reply omitted.
Solution
Expose the intermediate path of a multi-step run as an inspectable trail that keeps observable actions—tool calls, retrieved sources, commands, and their results—visually distinct from the model’s stated reasoning. Stream or group steps so the actor can follow progress while the run is under way, fold the trail to a compact summary once the reply settles so it stays reachable without pushing the answer away, and let the actor expand individual steps to inspect the underlying detail.
Do not present model thinking or its summary as a literal record of computation. Filter or redact sensitive tool inputs, returns, and prompt material before surfacing a trail to other actors or saving it to a shared log.
Continuation
Stream steps as they happen through live presentation, and fold the settled trail behind progressive disclosure so it does not bury the answer, using action consequences to decide how much stays open by default. Add mid-run redirection so the actor can steer off a wrong premise or wasted branch without restarting, and where an unchecked error would be costly, pair the fluent trail with cognitive forcing functions before acceptance. Pair the trail with citation to bind claims to retrieved passages and with expressed uncertainty where backtracking or conflicting tool results leave support thin. Once the run ends, attach the trail to generated content, carry it into change review to ground machine-proposed edits, anchor it into the lasting activity log, and preserve it for audit in collaboration…
All connections
- Precedes
- Mid-run redirection — spotting a flawed premise or wasted branch in the trail sets up steering the active run onto another path
- Cognitive forcing functions — a fluent trail invites rubber-stamping, which deliberate friction before acceptance interrupts
- Serves
- Delegation — work trail covers delegation's hood-to-look-under station during execution — inspecting how the agent worked and what it touched
- Enacts
- Agency — gives the actor checkable evidence of what the agent did and why, supporting calibrated trust and intervention
- Learnability — exposing the path an agent took lets the actor learn its capabilities, limits, and failure modes over time
- Complements
- Change review, collaboration, generated content — Once the run ends, attach the trail to generated content, carry it into change review to ground machine-proposed edits, anchor it into the lasting activity log, and preserve it for audit in collaboration
- Citation — Pair the trail with citation to bind claims to retrieved passages and with expressed uncertainty where backtracking or conflicting tool results leave support thin.
- Explanation — work trail exposes the multi-step path an agent took, whereas explanation lays out the factors, rules, or domain rationale behind a single-move output
- Live presentation — Stream steps as they happen through live presentation, and fold the settled trail behind progressive disclosure so it does not bury the answer, using action consequences to decide how much stays open by default.
- Plan preview — A plan preview may have stated what the run intended beforehand and a working plan may track which steps remain, leaving the actual execution path still to be exposed.
- Working plan — working plan holds which steps are left; work trail holds the actions and rationale behind them
- Activity log — the live and turn-scoped trail paired with the lasting record of the same work
- Expressed uncertainty — backtracking and conflicting tool results in the trail surface where support is thin
- Related to
- Prose
- Action consequences — governs how much of the trail warrants default visibility versus folding into a summary
- Preceded by
- Agent — generates the multi-step work and rationale that the work trail makes inspectable
- Assisted task completion — “the more of the work the system takes on, the more trust the actor has to extend before accepting anything — so how an offer accounts for itself stops being decoration”
- Enabled by
- Progressive disclosure — collapses the trail behind a summary line once the reply settles, letting the actor expand steps on demand
In practice
Dedicated run views
Outside a chat turn—in a side panel, coding agent, or run log—the trail stays expanded beside the work rather than folding above a reply.
Grouped and hierarchical trails
When a run spawns sub-agents, parallel tool calls, or backtracking branches, a flat chronological list buries where a branch went wrong. Grouping steps by sub-goal or showing a collapsible hierarchy makes errors easier to locate than a linear stream.
Research on this pattern
- Unfaithful chain-of-thought: Chen et al. (2025) tested reasoning models when subtle hints influenced the answer and found that models frequently used the hints without mentioning them in their reasoning trace, showing that visible chain-of-thought is a generated account rather than a reliable printout of computation.
- Structured interactive reasoning: Pang et al. (2025) organised verbose chain-of-thought into a navigable hierarchy of topics and found that actors spotted errors earlier, steered outputs more effectively, and formed clearer mental models than with flat text streams.
Resources & references
- Chen, Y., Benton, J., Radhakrishnan, A., Uesato, J., Denison, C., Schulman, J., Somani, A., Hase, P., Wagner, M., Roger, F., Mikulik, V., Bowman, S. R., Leike, J., Kaplan, J., & Perez, E. (2025). Reasoning Models Don’t Always Say What They Think
- Pang, R. Y., Feng, K. J. K., Feng, S., Li, C., Shi, W., Tsvetkov, Y., Heer, J., & Reinecke, K. (2025). Interactive Reasoning: Visualizing and Controlling Chain-of-Thought Reasoning in Large Language Models
- Shape of AI — Stream of thought