Claude Code, Codex CLI and friends do a lot between you pressing Enter and the final reply: read files, run shell commands, reason out loud, retry, backtrack. The terminal only shows you the polished, redacted top layer.

AgentMind sits between your agent and the LLM, so it sees the full unredacted truth — every request payload, every SSE chunk, every tool_use/tool_result pair, every thinking block — and lays it out as a three-pane inspector you can read like a code editor.

Use it to:

• Debug "why did my agent do that?" — see the exact tool args, the thinking that led there, the previous turn's tool_result it was reacting to.
• Audit context bloat — the request shows the full system prompt, every tool's JSON Schema, every cached message, and how much each iteration inherits.
• Learn how good agents are built — flip through Claude Code's real prompts and tool definitions, side-by-side with the responses they produce.
• Replay a project offline — everything is captured as plain JSONL on your disk; no telemetry, no account, no cloud.

npx agentmind-cli claude       # launch Claude Code through AgentMind
npx agentmind-cli codex        # or any codex args: …codex exec "ship the PR"

That's it. AgentMind boots the dashboard, injects the right env / config so your agent talks to the proxy, and hands the terminal off to the agent's TUI. Every prompt you type shows up in the dashboard as a new project — live, while the agent is still streaming. When the agent exits AgentMind exits with it. Browse the saved trace any time with npx agentmind-cli --no-agent.

Both agents reuse their existing logins — claude login for Claude Code, codex login for Codex CLI. No API key wrangling. The proxy sniffs the auth flavor (ChatGPT OAuth vs sk-…) and forwards to the correct upstream automatically.

Anything after the subcommand is forwarded verbatim to the agent, so wrappers like npx agentmind-cli codex --model gpt-5 --resume work.

Want it permanently on PATH? npm i -g agentmind-cli once, then drop the npx prefix everywhere below.

npx agentmind-cli --no-agent              # dashboard on http://127.0.0.1:8088
npx agentmind-cli --no-agent --port 9090  # custom port

Then point any agent at http://127.0.0.1:8088 — see Manual setup below.

Projects are keyed by (cwd, agent) — running both Claude and Codex in the same directory produces two distinct projects so each one's conversation chain stays coherent. The sidebar tags every project with a small agent chip (Claude = peach, Codex = lavender) so a mixed inbox stays scannable at a glance.

Flags (must come BEFORE the subcommand):

Run agentmind-cli --help for the full reference.

1. Projects (left) — one card per cwd you ran an agent in. Cards show the working directory, how long ago you were there, message count, total LLM round-trips, and a compact token tally.
2. Messages (middle) — one card per prompt you typed. Each card shows how many iterations the agent ran to satisfy it and whether it finished cleanly.
3. Conversation (right, the centerpiece) — one expandable card per HTTP round-trip:
   • REQUEST — system prompt, full tool JSON Schemas, the messages array. New messages added this iteration are tagged new, so context growth is obvious.
   • EXECUTE TOOLS — the in-between segment that runs locally between two API calls. Tool name, arguments, duration, success/error.
   • RESPONSE — thinking, text, tool_use blocks rendered as the model emitted them, with token counts and stop reason.

Open a card while the agent is mid-thought — the RESPONSE panel fills in as SSE chunks arrive (token-by-token text, tool args growing one delta at a time), and the REQUEST panel refreshes when the round-trip is sealed. A pulsing streaming badge and a live-ticking duration timer make the state unambiguous.

All capture is local-first JSONL — never leaves your machine.

~/.agentmind/
└── projects/
    └── <projectId>.jsonl     # projectId = sha256(cwd, agent).slice(0,16)

One file per (cwd, agent) pair — every claude run in the same directory appends to the Claude file for that cwd, every codex run to the Codex file. Pre-0.2.0 single-cwd files are migrated to the new scheme on first boot. Each line is one JSON record:

API keys in captured headers are redacted to sk-…NNNN — you can safely share a JSONL with a teammate without leaking your key.

• Local only. AgentMind binds to 127.0.0.1. The only outbound traffic is the proxied call your agent was going to make anyway — api.anthropic.com for Claude Code, api.openai.com or chatgpt.com/backend-api/codex for Codex CLI (we route by the bearer-token shape, not by config).
• No telemetry. Not now, not later. The only network calls are the ones you can see in the inspector.
• Read-only on disk. Captured JSONL is append-only; AgentMind never edits or deletes files you didn't ask it to. The one exception is the one-shot legacy migration at startup, which rewrites pre-0.2.0 files into the new (cwd, agent) layout — see migrateLegacy in src/server/storage.ts.

Anything that speaks the Anthropic Messages API (POST /v1/messages) or the OpenAI Responses API (POST /v1/responses) is captured. Adding a third protocol is one ProtocolAdapter away — see src/server/adapters.ts.

Most users don't need this — npx agentmind-cli claude / npx agentmind-cli codex handles the env/config wiring transparently. Reach for manual setup only if you're running the dashboard with --no-agent and want to start the agent yourself.

Claude Code — one env var:

ANTHROPIC_BASE_URL=http://127.0.0.1:8088 claude

Codex CLI — add a custom provider to ~/.codex/config.toml:

model_provider = "agentmind"

[model_providers.agentmind]
name = "AgentMind"
base_url = "http://127.0.0.1:8088/v1"
requires_openai_auth = true
wire_api = "responses"
supports_websockets = false

requires_openai_auth = true keeps Codex's normal auth selection (codex login OAuth or OPENAI_API_KEY) but routes through our base_url. supports_websockets = false is required because Codex prefers wss://…/responses first and AgentMind only speaks HTTP/SSE.

• TanStack Start (Vite-based SSR) · React 19 · TanStack Router
• Tailwind v4 · shadcn/ui · lucide-react · @uiw/react-json-view
• undici for upstream HTTP forwarding with full SSE pass-through
• pnpm · TypeScript 5.7

src/
├── routes/                       file-based routes
│   ├── __root.tsx                three-pane shell + header
│   ├── projects.$pid.tsx         project column wiring
│   └── projects.$pid.messages.$mid.tsx
│                                 message detail (the inspector)
├── components/
│   ├── ProjectsSidebar.tsx       left pane (projects)
│   ├── MessagesPane.tsx          middle pane (prompts)
│   ├── MessageDetail.tsx         right pane wrapper
│   ├── InteractionCard.tsx       one HTTP round-trip card
│   ├── RequestPanel.tsx          request rendering + diff badges
│   ├── ResponsePanel.tsx         response rendering (thinking/text/tool_use)
│   ├── ActionExecutionSegment.tsx local tool execution between calls
│   └── ui/                       shadcn primitives + JSON dialog
├── lib/
│   ├── anthropic-types.ts        Anthropic Messages API schema
│   ├── openai-responses-types.ts OpenAI Responses API schema (Codex)
│   └── api.ts                    typed fetch + subscribeLive helper
└── server/                       pure node, no React
    ├── adapters.ts               protocol adapters (one per agent)
    ├── middleware.ts             Connect middleware (mounted in vite.config.ts)
    ├── proxy.ts                  generic forwarder + SSE tee (per adapter)
    ├── liveRegistry.ts           in-memory live-streaming sessions
    ├── grouping.ts               (cwd, agent)-based project/message inference
    ├── projectId.ts              sha256(cwd, agent) ↔ projectId
    ├── aggregate.ts              raw capture → display model
    ├── interaction-view.ts       per-protocol view extractors
    ├── sse.ts                    Anthropic SSE parser
    ├── responses-sse.ts          OpenAI Responses SSE parser
    ├── prod-entry.ts             production CLI entrypoint (bundled into dist/)
    └── storage.ts                JSONL persistence + one-shot legacy migration

bin/cli.js                        global `agentmind-cli` entry
                                  (subcommands: `claude`, `codex`, `--no-agent`)
scripts/smoke-codex.mjs           e2e capture smoke (Codex + Anthropic + migration)
scripts/smoke-launcher.mjs        PATH-shim launcher smoke

pnpm install
pnpm dev          # http://127.0.0.1:8088 with HMR (uses vite)
pnpm typecheck    # strict tsc --noEmit
pnpm build        # produces dist/ — what npm publishes
pnpm start        # run the production bundle locally (no vite)
pnpm smoke        # build + end-to-end smoke (Codex + Anthropic + launcher)

The published package ships a prebuilt dist/ — end users running npx agentmind-cli never touch vite, tsx, or any dev dependency. The CLI boots a plain node:http server in under 100ms.

Optional env vars (testing/dev only — not user-facing):

• OpenAI Responses API capture (Codex CLI) — v0.2.0
• Codex CLI: action segments (function_call → function_call_output pairing) — v0.2.0
• Default agentmind-cli to launching Claude Code — v0.2.1
• Parse framework-injected input chrome (skills / memory / AGENTS.md / environment / …) into labeled chips — v0.2.3
• Promote skills and memory to top-level sections alongside tools / instructions — v0.2.3
• Codex CLI: helper-call filtering (compaction summariser)
• OpenCode CLI adapter
• Cross-project search & filters
• Diff view between adjacent iterations' transcripts
• Shareable "trace bundles" (export a sanitized project as a tarball)

Issues and PRs welcome at imsobear/agentmind. If you're hunting for something to do, the roadmap items above all have clean entry points — happy to mentor you through any of them.

MIT