1. What the workspace records
During generation, the app may record visible status messages, tool activity, and agent-produced notes. These help you review the workflow, but they are not a complete transcript of a provider's private reasoning.
The interface may show when a model or agent starts a step.
Some multi-agent runs store role-labeled text with the assistant message.
A saved scratchpad contains accumulated agent text, not the complete provider request.
The app may record visible tool status or results during a run.
Review the generated answer and verify important output independently.
2. Two Different Traces — Don't Confuse Them
Some APIs return a separate thought or reasoning field. The app can display text the provider actually returns, but availability depends on the provider and model. It cannot retrieve private reasoning that the provider omits.
The app's visible activity entries and agent-produced text. Review the live activity drawer or, when saved on a message, open Detailed Thinking Process.
3. How to Open & Inspect Traces
- During Generation: Open the activity drawer to follow the status entries the current run records. Provider thinking text appears only when the response includes it.
- After Generation: Open Detailed Thinking Process on an assistant message when that message contains saved steps or agent notes.
- Activity Drawer: The drawer shows activity collected for the current run; it is not a searchable archive of every turn or a window into hidden model internals.
4. What Good vs Bad Reasoning Looks Like
Intent: Build Pomodoro app (React + Tailwind + localStorage).
Plan: Use useEffect for 1s interval cleanup; store sessions in localStorage; handle null safety on mount.
Check: Pinned lucide-react icons present; wrapping output in canvas preview.
Intent: Explain the Pomodoro technique in markdown.
Plan: Output 5 paragraphs explaining timer benefits.
-> Action: Stop generation immediately and re-prompt to enforce code generation.
5. How to Use Traces to Fix Prompts — Practical Workflows
Open trace and search for your missing feature term (e.g., "CSV export"). If absent, move the requirement into a prominent bullet list at the top of your prompt.
Review the recorded activity entries and the final output against the original requirement. Treat agent notes as a review aid, then verify the actual result.
Check which saved agent notes and project context appear in the message. If a dependency matters, name it in your request and inspect the generated code before using it.
6. Scratchpad vs Execution Steps — Key Differences
Execution Steps: App-generated labels and activity text saved for a run. The entries are not an exhaustive audit of every model operation.
Agent Scratchpad: Accumulated text produced during multi-agent work. It is not the complete request payload or the provider's private reasoning, and it may contain prompt details or drafts.
7. Copying Traces & Privacy Hardening
Saved steps and scratchpad text may be stored with the assistant message. Chat exports or backups can include saved message data, so review it and keep passwords, API keys, and other secrets out of prompts and agent context.
8. Pro Tips for Trace Inspection
Monitor visible activity messages during a multi-agent run. Stop generation if the recorded work diverges from your request.
If an activity note captures a reusable preference, add it explicitly to Folder Memory and review that setting before future requests.
9. What Traces Cannot Tell You — Hard Limits
Traces are a window into the app's orchestration, not an X-ray into the model. Four specific things they will never show:
- The provider's private reasoning. If the API omits a thinking/reasoning field, no trace contains it — regardless of model, regardless of mode. "Show me your chain of thought" cannot be satisfied from the trace, only from whatever the provider chooses to return as text.
- The exact outbound request. Traces do not record the full system prompt, every retry header, or the provider's HTTP response — they record app-level steps. Use them for workflow review, not compliance audits.
- Why a model "believes" something. A trace shows what the app did, not the model's internal weights. Confidence language in output is still just text — verify claims downstream.
- Other users' or background requests. The drawer covers the current run only; it is not a log of every network call the page makes.
Takeaway: treat traces like application logs — invaluable for debugging the pipeline, useless as proof of anything happening inside the model.
10. Debugging a Failed Tool Call with the Trace
When the assistant says it searched/fetched/calculated and the result looks wrong (or "tool failed" appears), work the trace in this order:
- Find the tool marker. Locate the activity entry naming the tool (e.g. a search or fetch step) and check what query or URL it actually emitted — models frequently search the wrong query with total confidence.
- Inspect the payload context. If the fetched page is an SPA shell (few words, mostly scripts), the tool returned valid-but-empty content. Nothing to fix in the app — ask the model to search instead of fetch, or give it a direct URL to server-rendered content.
- Look for the fallback note. If a provider was unreachable, the entry may record the failure and the next route tried. Repeated immediate fallbacks usually mean a blocked domain (ad-blocker/firewall) or a dead local endpoint rather than a bad tool.
- Re-run narrowed. Stop the run, restate the task with the specific tool you want ("use web search, not fetch"), and watch the trace again. If the tool invocation differs from your intent, the prompt — not the tool — was ambiguous.
11. Comparing Traces Across Attempts and Models
Traces gain their real power when you diff them — across retries of the same prompt, and across models answering the same prompt:
Regenerate once and open both traces side by side. If attempt 2 diverged at the same step as attempt 1, the failure is systematic (prompt or context), not bad luck — change the prompt instead of re-rolling the dice a third time.
Fork the user prompt to a second branch, switch models, re-run, and compare where each model spent effort. The cheaper model skipping the verification step is often the single most useful trace observation you can make (see Part 8 for forking mechanics).
In Infinity loops, the trace is effectively your debugging console: read the Checker's verdict on each attempt, and if the Coder keeps getting flagged for the same class of issue (e.g. missing awaits), say so explicitly in your next prompt rather than waiting for attempt 3 to fail the same way.