Loading Accelerated Logic…
GA Release

The Multi-Agent WebGPU Engine & Interactions API are now generally available.

Part 7: Reviewing Agent Activity and Provider Thinking

Read saved app activity, review accumulated agent notes, and understand when a model provider returns separate thinking text.

Category: Getting Started • Read Time: 23 min read • Updated: 2026-11-10

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.

1. Run Status

The interface may show when a model or agent starts a step.

2. Agent Notes

Some multi-agent runs store role-labeled text with the assistant message.

3. Saved Scratchpad

A saved scratchpad contains accumulated agent text, not the complete provider request.

4. Tool Activity

The app may record visible tool status or results during a run.

5. Final Response

Review the generated answer and verify important output independently.

2. Two Different Traces — Don't Confuse Them

🧠 Provider-supplied thinking text

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.

⚡ Multi-Agent Execution Trace

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

✅ Good Trace Example

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.

❌ Bad Trace Example

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

Scenario 1: AI Missed a Key Requirement

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.

Scenario 2: Multi-Agent Code Bug

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.

Scenario 3: Model Used Unintended Library

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

Keep Drawer Open During Multi-Agent Runs

Monitor visible activity messages during a multi-agent run. Stop generation if the recorded work diverges from your request.

Refine Folder Memory from Good Traces

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:

  1. 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.
  2. 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.
  3. 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.
  4. 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:

Retry comparison (same model)

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.

Model comparison (fork the chat)

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.