💬 NLP

AgentGUI: An Interface for Observing and Steering Long-Running AI Agents

The paper introduces AgentGUI, a locally hosted graphical interface designed to enhance human oversight of long-running AI agents through rich trajectory visualizations and steering capabilities, which a user study shows significantly improves trace analysis speed and task completion rates.

Original authors: Xuan Zhao, Jiwoong Sohn, Qinyue Zheng, Michael Moor

Published 2026-07-30

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Xuan Zhao, Jiwoong Sohn, Qinyue Zheng, Michael Moor

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you've just hired a super-smart, tireless robot assistant to handle a massive, complicated project for you—maybe building a video game, writing a novel, or analyzing thousands of medical records. You tell it what to do, and it goes to work. But here's the catch: instead of checking in with you every five minutes, this robot decides to work for hours or even days straight without stopping. It's like sending a chef into a kitchen with a list of ingredients and a goal to make a feast, but you aren't allowed to peek inside until the meal is served. If the chef accidentally burns the soup or starts using the wrong spices, you won't know until it's too late. This is the world of "AI agents"—computer programs that can reason, use tools, and take actions on their own. While they are getting incredibly good at doing complex tasks, there's a growing problem: humans are struggling to keep up. We don't have a good way to watch what these robots are doing while they work, and if they start to go off-track (a problem researchers call "drift"), we often can't steer them back without restarting the whole thing.

This is where a new tool called AgentGUI comes in. Think of it as a high-tech, interactive control room for your robot workforce. The paper introduces AgentGUI as a user-friendly, locally hosted dashboard that lets you watch your AI agents in real-time, understand exactly what they are thinking and doing, and jump in to fix things if they get confused. Instead of staring at a boring, messy log of text that looks like a computer error message, AgentGUI turns the robot's activity into a colorful, easy-to-read visual story. It's like having a live camera feed into the robot's brain, showing you its steps, its mistakes, and its successes as they happen. The researchers wanted to see if this visual approach actually helps humans understand the robots better and stop them from going off the rails.

The Problem: The "Black Box" of Robot Work

When AI agents run long tasks, they leave behind a chaotic trail of thoughts, tool uses, and file changes. For a human, trying to read this trail is like trying to find a specific sentence in a book that's been shredded and mixed with a bag of confetti. It's overwhelming. If you spend hours trying to figure out what the robot did, you lose the time-saving benefit of having a robot in the first place. Worse, if you don't understand what it's doing, you can't teach it to do better or stop it from making a big mistake.

The Solution: A Pixel-Art Office for Robots

The authors built AgentGUI to solve this. Imagine a pixel-art office where every AI agent has its own desk.

The Dashboard: You see all your agents working at their desks. You can start a new task by dragging a file onto an empty desk or typing a prompt.
The View: When you click on a desk, you don't just see text. You see a timeline of the agent's life. There's a "live feed" showing exactly what the agent is doing right now (like "reading a file" or "writing code"), a "wall-clock" view showing how long it spent on each step, and even a terminal window showing the code it's running.
The Team: You can group agents into teams. A powerful agent can even review the work of a smaller, local agent, just like a senior editor checking a junior writer's draft.

How It Helps: Watching and Steering

The paper tested two main things: how well people could understand the robots, and whether the tool could stop robots from going off-track.

1. Understanding the Robot's Brain
The researchers ran a study with 8 students (who were experts in math and science but not the paper's authors). They asked these students to find specific information in the robot's work logs.

The Result: When using AgentGUI, the students found the answers 38% faster than when using the standard, text-heavy dashboard. On average, they took 90 seconds per question with AgentGUI, compared to 145 seconds with the old tool.
Accuracy: They also got more questions right (93% accuracy vs. 80%).
The Feeling: The students reported feeling less stressed and frustrated. It wasn't just faster; it was easier on the brain.

2. Stopping the Robot from Drifting
Sometimes, robots get stuck or start doing the wrong thing (drifting). AgentGUI has an automated "manager" feature. This is a second AI that quietly watches the first robot. If the first robot gets stuck or makes a mistake, the manager steps in, reads the situation, and tells the robot how to fix it.

The Experiment: They tested this with small, local AI models (ranging from 0.8 billion to 9 billion parameters) trying to organize 98 files into 15 different reports.
The Result: Without help, the smaller models often failed. But with the manager's intervention, the success rate jumped significantly. For the smallest model (0.8B), the success rate went from 10% to 26%. For the 4B model, it went from 44% to 78%. Even the strongest models (9B) saw a small bump from 92% to 98%.
The Cost: This "manager" was very cheap to run, using less than 1% of the total computing power needed for the task.

What This Means

The paper shows that giving humans a clear, visual window into what AI agents are doing makes a huge difference. It proves that we don't have to just trust the robot and hope for the best; we can actually watch, understand, and guide them. The authors are careful to note that their study was small and focused on specific types of tasks, so while the results are promising, there is still more to learn. However, the core idea is clear: to work safely with powerful AI, we need tools that make the invisible visible. AgentGUI is a step toward turning those confusing, messy robot logs into a story we can read, understand, and steer.

Technical Summary: AgentGUI

Problem Statement

As Large Language Model (LLM) agents become increasingly capable of executing complex, long-running tasks autonomously (e.g., software engineering, research hypothesis generation, and computer use), human oversight has struggled to keep pace. The primary bottleneck is the lack of human-centered interfaces capable of managing these "fleets" of agents. Long-running agents generate messy, interleaved transcripts of reasoning, tool calls, and file accesses that are difficult for humans to supervise. This opacity leads to two critical issues:

Inefficiency: Supervising agents by manually parsing raw traces negates the time-saving benefits of delegation.
Lack of Control: Without clear visibility, humans cannot effectively intervene to correct "drift" (deviation from the intended task) or customize agent behavior, hindering the reliability of autonomous workflows.

Existing tools often focus either on visualization (making behavior legible) or steering (allowing intervention), but rarely combine both, and they are frequently bound to specific agent harnesses, limiting interoperability.

Methodology

The authors introduce AgentGUI, an open-source, locally hosted Graphical User Interface (GUI) designed to observe, steer, and coordinate multiple concurrent AI agents. The system is built to support various open-source agent harnesses, with primary support for Hermes and experimental support for the Claude Agent SDK.

Core Architecture and Features

AgentGUI operates on a "desk" metaphor where each agent is assigned a workspace. The system integrates three main functional pillars:

Rich Trajectory Visualization:
- Activity Feed: Decomposes agent traces into reasoning, generation, tool requests, and responses with visual separation for skimming.
- Overview Feed: A wall-clock timeline showing time spent on specific tasks.
- Debug Terminal: Provides per-call API and token telemetry.
- Agent Console: A lightweight, code-centered terminal stream showing only agent actions in code execution.
- File Management: One-click previews of agent work directories and artifacts.
- Sub-agent Visualization: Mini-expandable avatars for agents spawned via delegation tools.
Manual and Automated Steering:
- Manual Intervention: Users can directly interrupt and redirect an agent's current turn via input or modify the task definition for the next turn. Users can also switch agent profiles (e.g., swapping a stalled local model for a more powerful one) mid-execution.
- Automated Audit Manager: An LLM-powered manager (using Qwen3.5-27B in experiments) that audits agent trajectories and artifacts. It decomposes tasks into verifiable criteria, gathers evidence from transcripts and files, and generates audit reports. If an agent is idle or drifting, the manager can prompt the agent to resume with corrective feedback.
Engineering and Security:
- Isolation: Each agent "desk" runs in a persistent, isolated Docker sandbox, preventing agents from affecting the host or each other.
- Scalability: The backend uses a FastAPI server with isolated worker processes, streaming events to a React frontend via WebSockets.
- Flexibility: Supports local execution via Ollama, remote GPU servers, and hosted inference options. It allows saving and restoring full session states (trajectories and workspaces) for portability.

Key Contributions

Unified Interface: AgentGUI is the first system to combine real-time trajectory visualization, manual/automated steering, and multi-agent coordination across different open-source harnesses in a single interface.
Drift Prevention Mechanism: The introduction of an automated audit manager that can detect task drift and intervene without requiring constant human monitoring.
Open-Source Accessibility: The system is released publicly with a demo video, aiming to lower the barrier for researchers and developers to manage complex agent fleets.

Results

User Study: Trajectory Comprehension

A controlled study with 8 MSc/PhD students compared AgentGUI against the native Hermes Dashboard (v0.16.0).

Speed: Participants identified key information from agent traces 38% faster using AgentGUI (average 90s per question vs. 145s for the baseline), with a statistically significant difference ( $p = 0.023$ ).
Accuracy: Accuracy improved from 80% (baseline) to 93% ( $p = 0.031$ ).
Workload: Participants reported statistically significant reductions in mental demand, frustration, and effort when using AgentGUI.
Scope: The study measured interface support for comprehension and lookup, not familiarity with a specific UI, as order and task assignments were counterbalanced.

Automated Steering Experiment

A proof-of-concept experiment tested the automated manager's ability to improve task completion rates for small local agents (0.8B–9B models) on a data aggregation task involving 98 files.

Completion Rate Lift: The manager significantly increased task completion rates across all model sizes. Notable improvements included:
- 0.8B model: 10% $\to$ 26%
- 4B model: 44% $\to$ 78%
- 9B model: 92% $\to$ 98%
Efficiency: The manager's token usage was negligible (<1% of total tokens), and the benefit was observed across all scales, suggesting the mechanism is general and not tied to specific worker capabilities.

Significance and Claims

The paper claims that observability is a precondition for trusting delegated work. By making agent activity legible and correctable in place, AgentGUI transforms opaque transcripts into outcomes that humans can verify, steer, and rely on. The system provides a human-centered approach to keeping long-running agents manageable in personal workflows.

The authors position AgentGUI as a substrate for future research in live supervision, broader harness support, and automated audits targeting open-ended quality. They acknowledge limitations, including the small sample size of the user study and the focus on quantitative completion metrics in the steering experiment, noting that future work should explore live human steering on multi-agent scales with qualitative evaluation.