Real-time visualization of Claude Code, Codex, and OpenCode agent orchestration. Watch your agents think, branch, and coordinate as they work. Demo video here.

I built Agent Flow while developing CraftMyGame, a game creation platform driven by AI agents. Debugging agent behavior was painful, so we made it visual. Now we're sharing it.

Claude Code is powerful, but its execution is a black box — you see the final result, not the journey. Agent Flow makes the invisible visible:

• Understand agent behavior — See how Claude breaks down problems, which tools it reaches for, and how subagents coordinate
• Debug tool call chains — When something goes wrong, trace the exact sequence of decisions and tool calls that led there
• See where time is spent — Identify slow tool calls, unnecessary branching, or redundant work at a glance
• Learn by watching — Build intuition for how to write better prompts by observing how Claude interprets and executes them

• Live agent visualization: Watch agent execution as an interactive node graph with real-time tool calls, branching, and return flows
• Claude Code + Codex + OpenCode: Auto-detects sessions from all three runtimes concurrently and shows them side-by-side, or restricts to one via the agentVisualizer.runtime setting
• Claude Code hooks: Lightweight HTTP hook server receives events directly from Claude Code for zero-latency streaming
• Codex rollout tailing: Reads ~/.codex/sessions/**/rollout-*.jsonl (respects CODEX_HOME) and surfaces tool calls, reasoning, and authoritative token counts from Codex's own event stream
• OpenCode SQLite tailing: Reads ~/.local/share/opencode/opencode.db (respects OPENCODE_DATA_DIR / XDG_DATA_HOME) and surfaces tool calls, reasoning, and message flow from OpenCode sessions
• Multi-session support: Track multiple concurrent agent sessions with tabs
• Interactive canvas: Pan, zoom, click agents and tool calls to inspect details
• Timeline & transcript panels: Review the full execution timeline, file attention heatmap, and message transcript
• JSONL log file support: Point at any JSONL event log to replay or watch agent activity

npx agent-flow-app

This starts the visualizer in your browser. Start a Claude Code session in another terminal — events will stream in real-time.

Options:

• --port <number> — change the server port (default: 3001)
• --no-open — don't open the browser automatically
• --verbose — show detailed event logs

git clone https://github.com/patoles/agent-flow.git
cd agent-flow
pnpm i
pnpm run setup      # configure Claude Code hooks (one-time)
pnpm run dev        # start the web app + event relay

Open http://localhost:3000 and start a Claude Code session in another terminal — events will stream to the browser in real-time.

To watch a different workspace while running the source app from the agent-flow repo, set AGENT_FLOW_WORKSPACE:

AGENT_FLOW_WORKSPACE=/path/to/your/project pnpm run dev

1. Install the extension
2. Open the Command Palette (Cmd+Shift+P) and run Agent Flow: Open Agent Flow
3. Start a Claude Code, Codex, or OpenCode session in your workspace — Agent Flow will auto-detect it

Agent Flow automatically configures Claude Code hooks the first time you open the panel. To manually reconfigure, run Agent Flow: Configure Claude Code Hooks from the Command Palette.

By default Agent Flow watches Claude Code (~/.claude/projects/), Codex (~/.codex/sessions/), and OpenCode (~/.local/share/opencode/opencode.db) concurrently in all three entry points (VS Code extension, pnpm run dev, npx agent-flow-app). Sessions are shown side-by-side and tagged by runtime. If you only use one, the others are harmless no-ops — no visible effect, no user action needed.

To restrict to one runtime:

• VS Code extension: set agentVisualizer.runtime to "auto" / "claude" / "codex" / "opencode" in your settings
• pnpm run dev and npx agent-flow-app: set the AGENT_FLOW_RUNTIME environment variable to claude, codex, or opencode (defaults to watching all three)

For non-default Codex installs, set the CODEX_HOME environment variable. For non-default OpenCode state locations, set OPENCODE_DATA_DIR or XDG_DATA_HOME.

You can also point Agent Flow at a JSONL event log file:

1. Set agentVisualizer.eventLogPath in your VS Code settings to the path of a .jsonl file
2. Agent Flow will tail the file and visualize events as they arrive

• Node.js 20+ (LTS recommended)
• pnpm
• Claude Code CLI
• For the VS Code extension: a VSCode-compatible IDE 1.85+ (e.g. VS Code, Cursor, Windsurf)

pnpm i              # install dependencies for all packages
pnpm run setup      # configure Claude Code hooks (one-time)
pnpm run dev        # start dev server + event relay

pnpm run dev starts both the Next.js dev server and an event relay that receives Claude Code events and streams them to the browser via SSE.

Other scripts:

Created by Simon Patole, for CraftMyGame.

Agent Flow ships opt-out anonymous usage telemetry, enabled by default only in the published npx agent-flow-app binary. pnpm run dev and the VS Code extension emit nothing. Only aggregate events are sent — session count, duration, event count, OS/arch, Agent Flow version, distinct model IDs observed, which runtimes were watched, and error class names. Prompts, file paths, tool calls, user info, and environment variables are never sent.

• Turn off: export AGENT_FLOW_TELEMETRY=false or export DO_NOT_TRACK=1 (disabled installs write zero state to disk — no ~/.agent-flow/ directory)
• Inspect the payload: cat ~/.agent-flow/telemetry/events.jsonl
• Full schema + exact fields: see the v0.8.1 entry in extension/CHANGELOG.md or the serialize() function in scripts/telemetry.ts
• Reset your anonymous identity: delete ~/.agent-flow/installation-id — a fresh random UUIDv4 will be generated on next run

Apache 2.0 — see LICENSE for details.

The name "Agent Flow" and associated logos are trademarks of Simon Patole. See TRADEMARK.md for usage guidelines.