How detailed should agent action traces be for human oversight?
Designing agent traces requires balancing completeness against cognitive load. Too much detail overwhelms users; summaries risk hiding errors while appearing reasonable.
Across a formative study (n=12), a design-probes study (n=12), and a final interface study (n=12) built around the human-in-the-loop computer-use agent Magentic-UI, the paper names one recurring problem for anyone designing how an agent reports its own actions: "determining the correct level of granularity for reporting agent actions is a crucial challenge." Full action-by-action traces were found "verbose, cumbersome, and time-consuming," causing participants to miss "small but impactful errors." Summarized views fixed the verbosity but introduced the opposite failure — participants "could overrely if the overall process is reasonable," citing a "'reasonable' process taken by the agent as their justification" even when the final answer was wrong. Of three summarizing probes tested, "Flowchart, the most process-oriented probe... had the lowest error-finding rate," while "Specification had the highest error-finding rate and was most preferred" but "took the longest" to review. The paper's own framing: "there is a tension between communicating the overall process while grounding in execution details."
The design response was not to pick a single granularity but to let users navigate between levels — a high-level, outcome-oriented specification linked directly into the underlying execution trace, so a person could stay at the summary level and drop into step detail where needed. This reduced the overreliance somewhat ("participants justified overreliance with a reasonable process less often in the controlled study than in the design probes study") but did not eliminate it, and the paper flags a specific hazard in its own interface: checked-requirement indicators ("a highly visible set of green checkmarks") could themselves inflate confidence if a requirement was incorrectly marked satisfied. A further extension the paper proposes but does not build: trace displays could show not just what the agent did but "what the agent did not do," since users wanted visibility into the alternative paths an agent chose not to take in an underspecified task.
This names the design problem underlying the sibling note Does a faster trace interface actually improve error detection? — that study's speed/accuracy/confidence result is this tension playing out in effect sizes. It also qualifies Can execution traces ground honest explanations of agent behavior?: grounding in the trace is necessary to avoid hiding execution errors, but the same grounding can be presented at a granularity that still invites a "reasonable process" judgment rather than a checked one. It bears on the orchestration layer of How should AI interfaces handle the shift from doing to supervising?, suggesting that layer needs explicit drill-down navigation between overview and step, not a single fixed level of detail.
The excerpt identifies the tension and one partial mitigation (linked navigation) but does not establish a design that resolves it: the final interface's own evaluation found faster error-finding without better accuracy, and the paper explicitly lists "further iteration on requirement and assumption content" as future work. The granularity tension is demonstrated for one CUA under Wizard-of-Oz conditions; whether the same two-sided failure mode (verbose-but-accurate versus summarized-but-overrelied-on) recurs in agent types with different output structures — code diffs, research reports — is not tested here.
Inquiring lines that read this note 2
This note is a source for these research framings, grouped by the broader line of inquiry each explores. Scan the bold lines of inquiry; follow any specific question forward.
Should agent evaluation measure execution quality beyond task success? Do reasoning traces accurately represent what models actually compute?Related concepts in this collection 5
This note in its neighbourhood — explore the map, then jump to a related concept in the list below.
Click a node to walk · click center to open · click Open in graph to see this note in the full knowledge graph
-
Does a faster trace interface actually improve error detection?
When AI agent traces are redesigned to be quicker to review, do users catch more errors overall, or just review faster? This matters for building interfaces that genuinely improve human oversight.
this study's quantitative result is this granularity tension expressed as effect sizes
-
Can execution traces ground honest explanations of agent behavior?
Multi-step AI agents leave execution traces behind, but can these raw records be converted into reliable, auditable explanations that expose unsupported claims? The question matters because human oversight of autonomous agents depends on trustworthy process-level transparency.
grounding in the trace is one side of this tension, not a resolution of it
-
How should AI interfaces handle the shift from doing to supervising?
Nielsen explores what UI architecture allows users to oversee AI work rather than perform it themselves. This matters because intent-based systems fundamentally change the user's role from operator to supervisor.
the tension sits specifically at the orchestration surface Nielsen proposes
-
Do developers actually review agent work exhaustively?
Research explores whether developers rely on comprehensive oversight of AI agent behavior or use shortcuts instead. This matters for understanding real-world AI safety practices versus idealized oversight models.
Evidence for A: developers cope with the granularity tension using heuristics like test results and skimming, not exhaustive review
-
Does human-in-the-loop design actually enable effective oversight?
When AI agents include humans in the decision loop, does that automatically provide meaningful oversight? The research explores what specific capabilities humans need to actually oversee agent behavior.
Extends A: the fallacy's knowledge/observation legs explain why detailed traces overwhelm and summaries hide errors while looking reasonable
Related papers in this collection 8
Papers most semantically related to this note, ranked by cosine similarity in the embedding space.
- Overseeing Agents Without Constant Oversight: Challenges and Opportunities
- Human oversight of agentic systems in practice: Examining the oversight work, challenges, and heuristics of developers using software agents
- The Oversight Fallacy: Why AI Agents Require More than Humans-in-the-Loop
- Assistance or Disruption? Exploring and Evaluating the Design and Trade-offs of Proactive AI Programming Support
- Holistic Agent Leaderboard: The Missing Infrastructure for AI Agent Evaluation
- Why Do Multi-agent LLM Systems Fail?
- Explaining Too Much? Understanding How Large Language Model Reasoning Traces Influence Performance and Metacognition
- COLLEAGUE.SKILL: Automated AI Skill Generation via Expert Knowledge Distillation
Original note title
trace design for agent oversight faces a granularity tension between overwhelming detail and overreliance on a reasonable-looking summary