Source-linked AI summary
Interactive Debugging and Steering of Multi-Agent AI Systems
Will Epperson, Gagan Bansal, Victor Dibia, Adam Fourney, Jack Gerrits, Erkang Zhu, Saleema Amershi
TL;DR
Developers face difficulty debugging long, dynamic conversations among autonomous agent teams, while existing tools lack fine-grained interactive control. The paper introduces AGDebugger, an interactive tool for inspecting, editing, resetting, and steering agent messages, then studies its use with 14 participants. The studies identify recurring steering strategies and emphasize interactive resets, while also exposing limits in configuration editing and study scope.
Problem
Existing tools do not adequately support debugging fully autonomous multi-agent teams across complex, multi-turn interactions.
Method
AGDebugger combines message browsing and sending with checkpoint-based editing and resetting plus an overview visualization for conversation histories.
Results
Participants commonly steered agents by adding detailed instructions, simplifying messages, and modifying plans, with message edits producing a correct outcome in the illustrated example.
Takeaways & Limitations
The findings support fine-grained interactive control for steering and debugging multi-agent AI teams.
Takeaways & Limitations
The study covered only two GAIA tasks and provided a 30-minute debugging session in its second part.
Abstract
from arXiv · showhide
Fully autonomous teams of LLM-powered AI agents are emerging that collaborate to perform complex tasks for users. What challenges do developers face when trying to build and debug these AI agent teams? In formative interviews with five AI agent developers, we identify core challenges: difficulty reviewing long agent conversations to localize errors, lack of support in current tools for interactive debugging, and the need for tool support to iterate on agent configuration. Based on these needs, we developed an interactive multi-agent debugging tool, AGDebugger, with a UI for browsing and sending messages, the ability to edit and reset prior agent messages, and an overview visualization for navigating complex message histories. In a two-part user study with 14 participants, we identify common user strategies for steering agents and highlight the importance of interactive message resets for debugging. Our studies deepen understanding of interfaces for debugging increasingly important agentic workflows.
1 Introduction
Multi-agent systems enable complex, tool-using workflows, but their long, dynamic interactions create debugging challenges that existing tools do not adequately support. The paper presents AGDebugger and studies how developers use it to diagnose and steer agent teams.
- Multi-agent systems combine LLMs with state tracking, tool use, and collaboration to perform complex real-world tasks.
- Existing tools inadequately support debugging fully autonomous agent teams across complex, multi-turn interactions.Prior tools focus mainly on individual prompts, model training, datasets, task execution, or agent construction.
- Debugging requires understanding individual agent behavior and emergent interactions to avoid cascading errors across the team.
- Five expert-developer interviews identified difficulties understanding long conversations, limited interactive debugging, and inadequate support for iterating on agent configurations.
- AGDebugger supports message inspection and sending, checkpoint-based resets and edits, and an overview visualization of conversations and changes.
- A 14-participant user study found steering strategies involving more detailed instructions, message simplification, and plan modification.
- The paper contributes formative findings, the AGDebugger prototype, and study results on diagnosing and experimenting with fixes for agent-workflow errors.
2 Related Work
Prior debugging research provides useful tools for models, prompts, and predefined LLM pipelines, but multi-agent systems add interaction, tool-use, memory, and long-conversation challenges. Existing multi-agent interfaces emphasize construction and task interaction more than interactive debugging.
- Multi-agent systems use specialized agents, planning, tools, and memory to divide complex tasks into subcomponents.
- LLM failure modes such as lost context and hallucinations can be exacerbated by chained model calls, complicating error tracking and resolution.
- Interactive machine-learning tools show the value of exposing raw decision-driving data and enabling users to explore counterfactual input changes.
- LLM debugging emphasizes prompt design, while existing tools let users experiment with system prompts and models for individual calls or pipelines.
- Multi-agent debugging must integrate individual behavior, tool use, memory, delegation, termination, and interactions over long conversations because local improvements can introduce errors elsewhere.
- AutoGen Studio, OpenDevin, and Crew AI support team construction and interaction but provide limited support for interactive debugging and related HCI research.
- Pause, reset, replay, and message-editing mechanisms have precedent, but prior LLM tools generally target single-model chats rather than multi-agent teams.
3 Background: Agent Framework and Tasks
The paper builds AGDebugger on AutoGen and evaluates agent teams on challenging GAIA tasks. Its example Magentic-One team uses five specialized agents, producing lengthy message histories that motivate interactive debugging.
- The background covers the agent framework, GAIA benchmark, and an example multi-agent team used for evaluation.
- AutoGen implements agents as Python classes that communicate through typed messages and handlers that may call LLMs, use tools, and send further messages.
- Agents also maintain internal thought logs and message histories that provide context for future model calls and debugging.
- GAIA evaluates AI assistants on challenging tasks requiring skills including coding, internet use, and file parsing across three difficulty levels.
- The study focuses on two GAIA Level-1 validation tasks that require searching and synthesizing information and that the team consistently answered incorrectly.
- Magentic-One comprises an Orchestrator, Coder, Executor, File Surfer, and Web Surfer with distinct tools and state.
- 71 messages and 6,368 words were used for T1, while 90 messages and 7,230 words were used for T2.
4 Formative Interviews on Agent Debugging
Interviews with five experienced developers identified three main pain points: interpreting long conversations, lacking interactive control, and slow configuration iteration. These findings shaped design goals for a debugging loop that alternates error identification with experimentation.
- 4 Formative Interviews on Agent Debugging: Five Microsoft developers experienced with AutoGen participated in interviews about multi-agent development challenges and desired debugging-tool features.
- 4.1 Understanding Long Agent Conversations is Cumbersome: Participants currently review console logs saved as single output files after workflow execution, making long conversations cumbersome to understand.
- 4.1 Understanding Long Agent Conversations is Cumbersome: A single task may generate 50–100+ text-heavy messages whose metadata, tool outputs, and growing multi-agent interactions are difficult to interpret.
- 4.2 Lack of Support for Interactive Debugging: Participants wanted breakpoints, interruption, resets, message editing, and step-by-step replay to inspect and steer agents during execution.
- 4.3 Iterating on Agent Configuration: Four participants described configuration iteration as slow because changing prompts, agents, or tools requires restarting workflows from the beginning.
- 4.4 Design Goals: The design goals require exposing agent messages, interrupting workflows, resetting to earlier points, and changing prompts or models to test fixes.
- 4.4 Design Goals: These goals support a debugging loop in which users identify errors and experiment with fixes to refine their understanding of the issue.
5 AGDebugger: Interactive Agent Debugging
AGDebugger supports interactive debugging of multi-agent workflows through message control, stateful resets and edits, and conversation-overview visualization. Its design combines fine-grained execution control with checkpoint-based workflow branching and tools for navigating long, edited histories.
- 5.1 Message Sending and History: AGDebugger lets users send messages to agents, inspect message histories, pause execution, and step through queued messages individually.Messages can be broadcast to all agents or sent to a specific agent, then processed automatically or one at a time.
- 5.2 Message Resetting and Edits: Users can reset a workflow to an earlier message, either retrying from that point or editing the historical message before restarting.Editing enables users to test more specific instructions and determine whether the workflow succeeds with a different request or plan.
- 5.2 Message Resetting and Edits: Checkpointing captures each agent’s state before message processing so resets can restore stateful environments rather than merely truncate the transcript.The system checkpoints state before every new message and restores agent states when a reset creates a new session.
- 5.2 Message Resetting and Edits: AGDebugger forks a new conversation session after a reset, preserving earlier messages and checkpoints while adding subsequent messages and checkpoints to the new branch.Resuming requeues the target message to continue the workflow from the restored point.
- 5.3 Conversation Overview Visualization: The overview visualization summarizes conversation messages and edits, helping users navigate long histories and compare passing or failing reset sessions.In the Figure 6 example, two earlier conversations fail while an edited final conversation produces the correct answer.
- 5.4 Agent Configuration: AGDebugger offers only basic agent configuration, allowing behavior tweaks during message-editing experiments but not serving as a primary configuration tool.The paper identifies deeper customization of agents and tools as a direction for future debugging systems.
6 User Study
The two-part user study examined how participants used AGDebugger to identify errors and steer multi-agent workflows. Interactive editing and resetting were central to debugging, while participants commonly refined instructions, simplified tasks, or changed plans.
- Study Design: Six participants diagnosed errors in two failed agent runs, while eight new participants edited and steered agents using AGDebugger.
- Part 1 Findings: Five of six participants preferred AGDebugger to the baseline, primarily because it supported interactive message editing and resetting.Participants’ error descriptions were equally high-quality across conditions, but AGDebugger’s extra features drove preference.
- Part 2 Findings: Two of eight participants steered agents to the exact correct answer, while interaction helped participants understand agent behavior and error sources.
- Part 2 Findings: Message resetting received the highest feature rating at 4.9/5, and every participant edited messages at least once during the 30-minute session.Several participants made five separate edits.
- Part 2 Findings: Participants used message edits for lightweight counterfactual testing, observing what would happen later after changing an earlier workflow message.
- Steering Approaches: Across eight sessions, participants made 24 edits: 14 added specific instructions, while other edits simplified instructions or modified the plan’s goal.The three categories were adding specific instructions, simplifying instructions, and modifying the plan.
- Steering Approaches: Specific instructions were the most common edit, including actionable steps such as sorting a table before returning its first-row result.
- Study Limitations: The study design was limited by 30-minute sessions and evaluation on only two GAIA benchmark tasks.The authors call for longer-term studies across other task types.
7 Discussion
AGDebugger extends interactive debugging to multi-agent teams by letting developers alter agent communications and explore counterfactual behavior. The discussion identifies steering, rollback, edit verification, robustness, and error-localization challenges that remain open.
- Interactive debugging: AGDebugger lets developers modify inter-agent messages to explore counterfactual effects on collective behavior.The system extends interactive probing from individual LLMs to multi-agent teams.
- Open challenges: Irreversible external actions, such as sending email, constrain checkpoint-and-reset mechanisms to internal state or undoable operations.The limitation motivates safeguards including monitoring, pre-execution validation, and stricter action constraints.
- Open challenges: Steering was easier with deeper implementation knowledge, because agents may impose specific constraints on instruction structure and tool use.Participants unsuccessfully assigned the Web Surfer multi-step plans even though it was designed for one task per instruction.
- Open challenges: Edits can be difficult to evaluate because stochastic LLM responses and accumulated conversation context obscure whether a change caused the observed behavior.Participants sometimes changed messages without seeing the agents follow the new plan.
- User steering strategies: Earlier conversation edits appeared more successful: both participants who reached the correct answer changed plans near the beginning rather than the end.Their successful edits changed the approach to web research or simplified the web-page plan.
- Future work: Future work should support direct performance feedback, robustness testing, and automatic error identification for long multi-turn conversations.Repeated trials can distinguish reliable edits from fortunate stochastic outcomes, while automatic identification could speed error localization.
8 Conclusion
AGDebugger enables steering multi-agent teams through message editing and rollback to earlier checkpoints. The study identifies steering strategies and open difficulties, motivating finer-grained, safer, and easier-to-reset agent interactions.
- 8 Conclusion: AGDebugger supports steering by editing messages exchanged between agents and reverting workflows to earlier checkpoints.The conclusion frames these capabilities as central to interactive debugging of multi-agent teams.
- 8 Conclusion: The user study reveals common steering strategies and open difficulties, including the need for fine-grained interactive control.Future work includes refining feedback mechanisms and designing interactions that are safe, easy to debug, and easy to reset.
A Formative interview details
The formative study used semi-structured interviews to examine developers’ experiences authoring multi-agent applications, including their tasks, obstacles, solutions, and unresolved pain points.
- A Formative interview details: Researchers conducted semi-structured interviews about participants’ experiences developing multi-agent systems.The interviews asked what tasks participants used AutoGen for and why.
- A Formative interview details: Interview questions covered prior approaches, obstacles in AutoGen authoring, how difficulties were solved, and unresolved pain points.The questions focused on participants’ own development experiences.
B User study part 2 questions
The second user-study component combined Likert-scale and yes/no survey questions with open-response interviews about participants’ backgrounds, system experience, feature helpfulness, and steering approaches.
- B User study part 2 questions: Participants rated the system’s helpfulness, ease of use, future usefulness, and the helpfulness of its debugging features on five-point Likert scales.Features included sending messages, backtracking and editing prior messages, and conversation overview visualization.
- B User study part 2 questions: The survey asked about participants’ AI-agent experience and prior use of AutoGen, AGNext, and the GAIA benchmark.Experience with AutoGen or AGNext and GAIA was recorded using yes/no questions.
- B User study part 2 questions: Open-response questions examined participants’ steering approaches, perceived ability to reach the correct answer, actionable issues, and desired steering methods.Participants also described how editing messages and configuration influenced their understanding of agent errors.