Turning Claude Code Sub-Agents into a Video Call: A New Way to Visualize Multi-Agent Work

When Your Terminal Becomes a Wall of Logs

When using Claude Code, the moment a main agent spawns multiple sub-agents, your terminal can instantly become an overwhelming wall of logs. It's hard to tell: who got which task? What commands is each sub-agent running? Which ones have finished, and which are stuck?

A Reddit developer (GitHub user Atoll92) solved this problem with a surprisingly clever approach — he turned Claude Code sessions into a "video call." An open-source VS Code extension called Agent Standup gives each sub-agent its own avatar in a "call" interface, presenting the entire multi-agent collaboration in a humanized way.

What Agent Standup Actually Does

The core logic isn't overly complex, but the product presentation is genuinely clever. It reads directly from the session files Claude Code already writes to the ~/.claude/projects directory (conversation records in JSONL format) and tracks the current session in real time.

The key is how it transforms dry logs into an intuitive "meeting" view:

• Character-ified agents: Each sub-agent appears as an avatar in the call — they "join" when assigned a task and "leave" after reporting results.
• Shared screen: A shared "screen" displays the actual commands and outputs the agent executed, precise diffs of files it edited, and files it read — with failed tests highlighted in red.
• Call tree: A tree diagram showing "who called whom," making multi-level agent delegation relationships immediately clear.
• Change review and playback: A summary of modified files, support for replaying past sessions, and optional French/English voice narration.

Beyond the VS Code extension, it also works with other editors or as a standalone Node server paired with the Claude app. The entire project is open-sourced under the MIT license, and the author explicitly notes this is an unofficial tool with no affiliation with Anthropic.

JSONL (JSON Lines) is a text format where each line stores a single independent JSON object, commonly used for logs and streaming data. Claude Code appends messages, tool calls, sub-agent spawning events, and other occurrences from each conversation to these files one by one, forming a complete transcript. Agent Standup continuously polls or watches these files for changes, parsing incremental events and mapping them to UI state — meaning it requires no access to Claude Code's internal APIs whatsoever. It runs entirely on existing file artifacts, which is precisely why this unofficial tool can operate reliably.

Using Claude Code to Build a Tool That Observes Claude Code

The most fascinating aspect of this project is that it was almost entirely built by Claude Code itself — in the author's own words, the whole project was created during "a two-day-long Claude Code conversation."

In terms of the division of labor, Claude Code handled nearly all the coding:

• Writing a Node server to parse JSONL transcript files (including sub-agent files and tool call result parsing);
• Building the browser frontend;
• Drawing SVG characters and backgrounds;
• Packaging the VS Code extension;
• Testing the UI in a headless browser;
• Bundling the extension, publishing GitHub Releases, and creating the landing page.

The human developer's role stepped back to a higher level: proposing ideas, making product decisions, and testing in a real VS Code environment. One particularly telling collaboration detail: when the author sent Claude a screenshot of a bug, Claude accurately identified the root cause. For instance, an issue where avatars turned transparent turned out to be caused by duplicate gradient IDs between two SVG copies of the same character — the kind of problem that can be extremely time-consuming to track down manually.

This division of "humans provide ideas, AI provides implementation" is becoming a typical working pattern for AI-assisted programming, and serves as indirect evidence of Claude Code's real-world capability on mid-sized full-stack projects.

The duplicate gradient ID issue is a classic trap in the SVG spec: SVG uses id attributes defined in <defs> blocks to globally reference gradients, filters, and other resources within a document. When multiple SVG fragments are inlined into the same HTML page, identical id values create naming conflicts — the browser keeps only the first definition it encounters, and subsequent references to the same name may fail to resolve or fall back to transparent. This type of bug is extremely difficult to catch through manual code review, because each SVG file appears perfectly fine when previewed in isolation; the conflict only surfaces during combined rendering. This illustrates exactly where AI has an efficiency advantage over human review in cross-file, cross-context static analysis.

Why "Video Call" Is a Great Metaphor

The biggest observability challenge in multi-agent systems is information overload caused by parallelism and hierarchical relationships. A traditional linear log stream can't express "things happening simultaneously" and "who belongs to whom" at the same time.

Agent Standup borrows the most familiar collaboration scenario humans know — the video meeting — to carry both layers of information. Joining and leaving maps to task lifecycles, screen sharing maps to execution context, and the call tree maps to organizational structure. This anthropomorphization isn't purely a visual gimmick; it maps abstract process states onto the social and spatial cognition that the human brain is wired to handle, reducing cognitive load.

Of course, tools like this have their limits: they depend on Claude Code's existing session file format, so any change to the underlying transcript structure would require an update. Whether the visualization remains clear as the number of agents grows very large is also worth watching.

Observability in multi-agent systems is one of the central challenges in AI engineering today. Traditional software observability focuses on three dimensions: metrics, logs, and traces. But LLM agents introduce new complexity: a single "call" can trigger dozens of tool-use steps, and task delegation between agents forms a dynamic directed acyclic graph rather than a predefined call stack. Dedicated LLM observability platforms like LangSmith, Langfuse, and Phoenix already exist in the industry, typically collecting data through SDK instrumentation or proxy interception. Agent Standup takes a lighter-weight path — consuming Claude Code's existing file output directly — sacrificing generality in exchange for a zero-intrusion deployment experience.

How to Install and Try It

The tool is currently free and open-source, with a low barrier to entry:

1. Download the .vsix file from the project site;
2. In VS Code, go to Extensions → … → Install from VSIX to complete installation;
3. If you don't have an active session handy, open ⚙ → Source → Demo to view the built-in fictional example.

The author notes that macOS is the most thoroughly tested platform; Windows should work in theory, but more bug reports are welcome.

Relevant links:

• Site and download: https://atoll92.github.io/agent-standup/
• Source code: https://github.com/Atoll92/agent-standup
• VS Code Marketplace: https://marketplace.visualstudio.com/items?itemName=DoubleGeste.agent-standup

For developers who frequently use Claude Code's multi-agent workflows, this is a visualization and observability solution worth trying — even if only as a learning tool for understanding how multi-agent collaboration actually works, its presentation approach offers genuine insight.