Skip to main content

Transparency and Interruptibility - When to Show the Agent's Thinking

· 3 min read
Calvin Cheng
Calvin Cheng
Shape what gets built and the value it creates.

AI agents can pursue wrong directions for a long time before producing output. By the time you see the result, significant time and tokens are wasted. The alternative - exposing the agent's reasoning in real time - adds cognitive load and can feel noisy. The design question: when should users see the agent's thinking, and when should they be able to interrupt?

The Transparency Trade-off​

Too opaque: The agent is a black box. You submit a task, you wait, you get output. If the output is wrong, you have no idea why. Debugging means retrying blindly or digging through logs. Trust is low because understanding is low.

Too transparent: The agent streams every reasoning step, every tool call, every alternative considered. The UI becomes a firehose. Users glaze over or get paralyzed by the volume. The cost of parsing exceeds the benefit of visibility.

The right balance depends on context: task complexity, user expertise, and whether the user is actively supervising or passively waiting.

When Transparency Helps​

  • Complex, multi-step tasks where wrong early choices cascade (e.g., wrong file selected, wrong approach assumed)
  • High-stakes operations (database migrations, API changes) where catching errors early matters
  • Learning and debugging when the user wants to understand how to prompt better or why something failed
  • Active supervision when the user is "finger on the trigger" and ready to intervene

When to Allow Interruption​

Interruption is the complement to transparency. If you show reasoning, you should allow the user to stop it - and ideally to redirect. "Use oauth.ts instead of auth.ts." "Wrong approach; try Y." The agent can then correct course without completing a flawed sequence.

Key design decisions:

When to show reasoning: Default to summary for simple tasks; expose detail on demand (e.g., Ctrl+R for verbose mode). Let power users opt in.

How to interrupt: Prominent stop control, minimal friction. Preserve partial work when possible - don't force "start over."

How to redirect: After interruption, allow the user to inject context or correction. "I meant X" should flow back into the agent's next step.

UI Patterns​

Streaming with collapsible detail: Show high-level progress (e.g., "Reading auth.ts... Modifying...") by default. Expand to see full reasoning, tool calls, and alternatives for those who want it.

Pre-execution preview: For tools that have side effects, show "about to do X" before doing it. Gives the user a moment to interrupt if X is wrong.

Early signal highlighting: Emphasize the first tool calls and assumptions - those are where misunderstandings surface. Later steps often compound early errors.

The Meta-Pattern​

Transparency and interruptibility together form a supervision loop: the user can observe, judge, and intervene. Not every task needs it. Fire-and-forget has its place. But for tasks where wrong directions are costly, the loop is essential. The design challenge is making it available without making it mandatory - supporting both "watch and steer" and "spawn and review later" in the same product.