You handed your codebase to an AI coding agent, it rewrote twelve files, and the test suite passes. But if someone asked you why the agent touched three files you never mentioned, you'd have no answer — because session logs record actions, not reasoning. In 2026, a new generation of tools solves exactly this problem: they visualize what your agent did, where it wandered, and whether it explored before it acted. Mindwalk renders your repo as a 3D city and replays the session as colored light moving through it; AgentFlow draws a directed graph of every tool call inside VS Code; Agent Replay gives you a DevTools-style timeline with diffs; and VS Code's built-in Agent Debug Log panel shows the full event sequence without leaving your editor.
Last verified: 2026-07-30
- Best for 3D replay + AI grading: Mindwalk (open source, MIT, GitHub)
- Best in-editor DAG: AgentFlow (VS Code extension, free)
- Best timeline + diffs: Agent Replay (open source, GitHub)
- Best built-in: VS Code Agent Debug Log panel (no install needed, Copilot users)
- Pricing/limits change often — last checked July 2026.
Why session logs are not enough
A session log — the JSONL file that Claude Code writes to ~/.claude/projects/ or that Codex writes to ~/.codex/sessions/ — documents what happened: which files were read, which were edited, which commands ran. It does not answer the questions that actually matter for a code review:
- Did the agent explore enough before it started editing?
- Did it stay in scope, or did it quietly wander through half the repository?
- What did it read and discard?
- Where did a subagent spin up, and what did it do?
- Did it bother to verify its own work?
Reading raw JSONL line by line does not surface any of this. The shape of the agent's reasoning — which parts of the repo it treated as relevant, where it looked before it changed a single line — is invisible in a flat text log. That gap is the problem every tool in this space is trying to close.
What is Mindwalk and how does it work?
Mindwalk is an open-source (MIT-licensed) tool that reads Claude Code and Codex session logs, renders your repository as a 3D night-map, and plays the agent session back as light moving through it. It is a single Go binary with a Three.js frontend that runs entirely in your browser — no server, no account, no telemetry. It was created in July 2026 and has attracted nearly 1,000 GitHub stars (cosmtrek/mindwalk, confirmed 2026-07-30).
The color language
Mindwalk uses a cool-to-warm spectrum to encode what the agent did to each file:
| Color | State | Meaning |
|---|---|---|
| Moss green | Seen | Agent glanced at the file |
| Moonlight blue | Read | Agent sat down and read it |
| Warm amber | Edited | Agent made changes |
| Dark | Unvisited | Agent never touched it |
The timeline is also annotated with symbols: ◇ marks where the context window was compacted, ○ marks subagent launches, and › marks user turns. Every mark is a click-to-jump target — you can drag the playhead back and forth to trace the exact path the agent walked through the code.
The analyze command — a judge for your session
The feature that sets Mindwalk apart from a pretty visualization is mindwalk analyze. It runs your own local claude or codex CLI as a "judge" over the session you just replayed, and it grades the run across four categories:
- Exploration — did the agent look around enough before editing?
- Scope — did it stay within the boundaries of the task?
- Wandering — did it drift into unrelated parts of the codebase?
- Verification — did it check its own work after making changes?
Every finding is a clickable link that jumps to that moment on the timeline. The judge subprocess runs sealed — no tools, no MCP servers, no project settings, no session persistence — so it cannot accidentally modify your code. Reports are cached in ~/.mindwalk/reports and go stale (never auto-rerun) when the session content changes (Mindwalk README).
Quick start
curl -fsSL https://raw.githubusercontent.com/cosmtrek/mindwalk/master/scripts/install.sh | sh
export PATH="$HOME/.local/bin:$PATH"
mindwalk
With no arguments, Mindwalk scans ~/.claude/projects and ~/.codex/sessions, serves a UI on a random local port, and opens your browser. Key commands:
| Command | What it does |
|---|---|
mindwalk serve |
Serve all discovered sessions with a web UI |
mindwalk open <session.jsonl> |
Open one specific session |
mindwalk map <repo> |
Render any repo as a 3D city — no session needed |
mindwalk analyze <session> |
Run the judge and produce a graded report |
mindwalk trace <session> |
Export the normalized trace as JSON |
What Mindwalk does not support yet
Mindwalk only reads Claude Code and Codex session logs (confirmed 2026-07-30, GitHub). If you live in Cursor, Windsurf, or GitHub Copilot's CLI, you cannot replay your sessions yet. For more on running those agents at no cost, our guide on how to run Claude Code for free in 2026 covers the setup that sidesteps the Anthropic paywall. It is also early — version 0.3 territory — so expect rough edges.
How does Mindwalk compare to AgentFlow, Agent Replay, and VS Code's built-in tools?
Each tool approaches the same problem — "show me what my agent did" — from a different angle. Here is the comparison:
| Feature | Mindwalk | AgentFlow | Agent Replay | VS Code Agent Debug Log |
|---|---|---|---|---|
| Format | 3D city replay | Interactive DAG (graph) | Timeline UI | Event log + flow chart panel |
| Where it runs | Browser (Go binary) | Inside VS Code | Browser (Node) | Inside VS Code |
| Session sources | Claude Code, Codex | Claude Code, Cursor | Claude Code, Cursor | GitHub Copilot Chat |
| Live monitoring | No (post-mortem) | Yes (watch live) | No (post-mortem) | Yes (current session) |
| AI grading | Yes (local LLM judge) | No | No | No (/troubleshoot Q&A) |
| Diff view | No | Node inspector | Yes (syntax-highlighted) | Raw payload inspector |
| Subagent visualization | Agent lens toggle | Collapsible containers | No | Agent Flow Chart view |
| Cost/token tracking | No | Yes (estimates) | Yes | Yes (Summary view) |
| License | MIT | Free (proprietary) | MIT | Built into VS Code |
| Installs | Self-install (Go binary) | ~152 (Marketplace) | npx agent-replay | VS Code 1.103+ |
Sources: Mindwalk README, AgentFlow Marketplace listing, AgentReplay README, VS Code Agent Debug docs. All confirmed 2026-07-30.
When should you use each tool?
Use Mindwalk when you need to understand an agent's reasoning shape after a large, sprawling change where a flat diff does not tell you what happened. The 3D flythrough plus the judge report is the only combination that shows you the agent's exploration pattern and grades it. It is also the right pick if you are comparing models — say, how Claude explores a task differently from Codex — because the visualization normalizes both into the same map format.
Use AgentFlow when you want visual debugging inside your editor without installing a separate binary. It supports live monitoring (you can watch your agent work in real time) and renders the full decision tree as a DAG with 12 node types and 6 edge types. It is the best choice for understanding subagent orchestration trees.
Use Agent Replay when you need a Chrome-DevTools-for-agents experience — a timeline you can step through event by event, with syntax-highlighted diffs, bash output rendering, and token/cost tracking per session. It is the best tool for auditing individual file edits and command outputs after the fact.
Use VS Code's built-in Agent Debug Log when you are already using GitHub Copilot Chat in VS Code and want zero install. The Summary view shows aggregate session stats (model turns, tool calls, tokens, errors), the Flow Chart visualizes subagent interactions, and /troubleshoot lets you ask plain-language questions about the session. The trade-off: it only covers Copilot Chat sessions, and logs are not persisted across VS Code restarts.
What about Graphify — is it the same thing?
No. Graphify (Apache 2.0, GitHub, launched July 1, 2026) is a different category: it turns your codebase into a queryable knowledge graph that your AI assistant navigates before it starts working — so the agent greps the graph instead of the file system. Mindwalk shows you what happened after the run. They address opposite ends of the same problem: Graphify improves where the agent looks; Mindwalk shows you where it actually went. They are complementary, not competitive.
How to run Mindwalk on a real session (step by step)
Install the binary.
curl -fsSL https://raw.githubusercontent.com/cosmtrek/mindwalk/master/scripts/install.sh | sh export PATH="$HOME/.local/bin:$PATH"Run a Claude Code or Codex session on your project (if you have not already). Mindwalk auto-discovers session logs in
~/.claude/projectsand~/.codex/sessions.Launch Mindwalk.
mindwalkIt scans for sessions, opens a browser tab, and lists everything it found.
Pick a session and press play. Watch the colors: green = seen, blue = read, amber = edited. Drag the timeline to scrub. Look for
◇compaction marks (the agent lost context) and○subagent marks (work was delegated).Run the judge.
mindwalk analyze <session.jsonl> --judge claude --model sonnetThe judge returns findings on exploration, scope, wandering, and verification — each clickable back to the timeline moment. You need a working
claudeorcodexCLI installed locally for this to work. For setup help, see our complete guides on how to run Claude Code for free and how to run OpenAI Codex CLI. The "doer-judge" pattern this tool automates is also worth understanding on its own — our field guide to the doer-judge loop explains why a strong judge paired with a cheap builder wins on both cost and quality.Optional: render a repo without a session.
mindwalk map /path/to/your/repoThis gives you a 3D city where building height encodes lines of code — a useful orientation tool even without any agent activity.
What this means for you
If you are shipping code written by AI agents and reviewing it only via git diff, you are reviewing the what but not the how. For a two-line fix, that is fine — read the diff and move on. For a 12-file refactor where the difference between "the agent understood the task" and "the agent guessed and got lucky" is invisible in the diff, you need a session visualization tool.
The practical split:
- Small changes →
git diffis faster than any visualization tool. Use it. - Large agent runs → use Mindwalk or Agent Replay to see the shape of what happened. If the tool shows the agent stayed in scope and verified its work, you can review with confidence. If it shows wandering across half the repo with no verification, you know where to look before approving. For a deeper framework on making agent loop safety a engineering discipline, see our guide on how to engineer AI agent loops that are safe for production codebases.
- Multi-agent orchestration → use AgentFlow's DAG view to understand how subagents were invoked and what each one did.
- Live debugging → use AgentFlow's watch mode or VS Code's Agent Debug Log to watch the agent work in real time.
We taught machines to write code far faster than we built ways to understand what they wrote. These tools are the first serious attempts to close that gap. For more on why AI can do the work but still can't do the understanding, see our analysis on AI skill atrophy and the limits of LLM comprehension.
FAQ
Q: What is the best free tool for visualizing AI coding agent sessions? A: Mindwalk (MIT) and Agent Replay (MIT) are both free and open source. Mindwalk offers 3D replay and AI grading; Agent Replay gives you a DevTools-style timeline with diffs. AgentFlow is a free VS Code extension (proprietary license) for in-editor DAG visualization.
Q: Does Mindwalk work with Cursor sessions? A: No. As of July 2026, Mindwalk only reads Claude Code and Codex JSONL session logs. Cursor session data lives in a SQLite database that AgentFlow and Agent Replay can read, but Mindwalk does not support it yet (Mindwalk README).
Q: Does Mindwalk send my code to the cloud?
A: No. Viewing sessions is entirely local — no network calls during playback. The only outbound call is optional: when you run mindwalk analyze, it sends a session summary (user message wording, file paths, one-line event digests — not full file contents) to your own Claude or Codex account for grading. The judge subprocess runs sealed with no tools, no MCP servers, and no project settings (Mindwalk README).
Q: Is 3D code visualization actually new? A: The 3D "city metaphor" for codebase visualization dates back to CodeCity (Wettel and Lanza, ICSE 2008, DOI 10.1145/1370175.1370188), which depicted classes as buildings and packages as districts. What is new in 2026 is applying this metaphor to agent session replay — showing how an AI agent moved through the city, not just the city itself.
Q: Can I compare how different AI models explore the same codebase? A: Yes — this is one of Mindwalk's strongest use cases. Because it normalizes traces from both Claude Code and Codex into the same format and renders them on the same 3D map, you can replay a Claude session and a Codex session on the same repository and visually compare which files each agent explored, where it lingered, and where it edited.
Q: What is the difference between Graphify and Mindwalk? A: Graphify builds a knowledge graph of your codebase that your AI assistant queries before it starts working — it helps the agent find the right files. Mindwalk visualizes what the agent already did — it shows you the session after it ran. They solve opposite ends of the same problem and can be used together.
Discussion
0 comments