agentsview Review: Local Analytics for 20+ Coding Agents

TL;DR

agentsview is a single-binary, local-first analytics tool that indexes the session files of 20+ AI coding agents — Claude Code, Codex, Cursor, Copilot CLI, Gemini, Amp, Aider, Forge, Kilo, Kiro, iFlow, gptme, and more — into a local SQLite database and gives you full-text search, cost tracking, activity heatmaps, and a web dashboard at http://127.0.0.1:8080. It bills itself (correctly) as a “100× faster replacement for ccusage,” because it indexes session JSONL once instead of re-parsing on every query. The repo is 2,901 stars and adding 1,382 this week, written in Go, MIT-licensed, and runs as one binary with no accounts, no telemetry, and no cloud dependency.

The pitch is sharp: if you use more than one coding agent — and almost everyone does in 2026 — there is no single place to see what your sessions did, how much they cost, or what they actually wrote. ccusage covers Claude Code. The OpenAI dashboard covers Codex. Cursor’s billing page covers Cursor. agentsview is the first tool I’ve seen that puts all of them in one searchable database, locally, with no API keys.

Key facts:

2,901 GitHub stars, 1,382 added this week, written in Go (single static binary)
20+ supported agents auto-discovered from their session directories on first run
Full-text search across all messages via SQLite FTS5
Per-agent, per-model, per-session cost tracking using live LiteLLM pricing (offline fallback)
Prompt-caching-aware cost math (separates cache-creation vs cache-read tokens)
Live updates via Server-Sent Events as your active sessions append messages
Desktop apps for macOS and Windows, plus Homebrew cask, plus Docker, plus a curl-pipe-bash installer
MIT licensed, runs entirely on 127.0.0.1 with Host-header DNS-rebinding protection by default

Why this is a real problem

If you’ve watched your monthly bills over the last six months, you know the shape of this problem. A typical 2026 engineer’s setup looks like:

Claude Code in the IDE for the heavy refactors
Codex in the terminal for one-shot scripts and CI debugging
Cursor for inline edits inside the editor
Copilot CLI in gh for repo automation
Maybe Aider or Forge or Gemini CLI on the side

That’s five different APIs, five different billing dashboards, five different session formats — and zero ways to ask “what did I work on yesterday?” without opening five different things. Worse, the existing cost-tracking tools (ccusage for Claude, the OpenAI usage dashboard for Codex, etc.) each only know about one agent and re-parse files on every invocation, which means asking “how much did I spend across all my agents this month?” is a half-hour data-engineering exercise.

agentsview is the obvious-in-retrospect fix. It walks ~/.claude/projects/, ~/.codex/sessions/, ~/.cursor/projects/, and the 17+ other session directories at startup, parses everything once into SQLite, and then everything you’d want — search, daily-spend charts, per-project breakdowns — is a single SQL query or one CLI call against an already-indexed database.

Install in 60 seconds

# macOS / Linux
curl -fsSL https://agentsview.io/install.sh | bash

# Windows
powershell -ExecutionPolicy ByPass -c "irm https://agentsview.io/install.ps1 | iex"

# Or Homebrew (macOS, includes the desktop app)
brew install --cask agentsview

# Or Docker
docker run --rm -p 127.0.0.1:8080:8080 \
  -v agentsview-data:/data \
  -v "$HOME/.claude/projects:/agents/claude:ro" \
  -v "$HOME/.codex/sessions:/agents/codex:ro" \
  -e CLAUDE_PROJECTS_DIR=/agents/claude \
  -e CODEX_SESSIONS_DIR=/agents/codex \
  ghcr.io/kenn-io/agentsview:latest

Then:

agentsview serve --background     # start the dashboard server
agentsview serve status           # confirm it's running
open http://127.0.0.1:8080        # browse sessions in the web UI

That’s the entire setup. On first run, it discovers every session directory that exists on your machine, imports the lot into ~/.agentsview/sessions.db, and starts serving the dashboard. Background mode logs to ~/.agentsview/serve.log and prints the PID so you can agentsview serve stop later.

The killer feature: `agentsview usage daily`

This is the one most people will install for. ccusage already exists for Claude Code, but it only covers Claude Code and it re-parses raw JSONL on every invocation. agentsview usage covers everything and queries the already-built SQLite index — the docs claim 100× faster, and in practice it’s instant.

# Daily cost summary (last 30 days, all agents)
agentsview usage daily

# Per-model breakdown
agentsview usage daily --breakdown

# Filter to one agent, one date range
agentsview usage daily --agent claude --since 2026-04-01 --until 2026-05-01

# One-line for shell prompts (works in starship, oh-my-zsh, fish)
agentsview usage statusline

# JSON for scripts
agentsview usage daily --all --json | jq '.totals'

It uses LiteLLM pricing tables for live rates with an offline fallback, and it correctly separates cache-creation tokens, cache-read tokens, input tokens, and output tokens — which is the part ccusage and the OpenAI dashboard tend to get wrong. If you’ve ever wondered why your Anthropic bill is half what your token count suggests, that’s prompt caching; agentsview’s math actually models it.

The standalone usage mode is particularly nice for CI: you don’t need to run the server, you can just SSH onto a build box and agentsview usage daily --json to dump cost data into a Prometheus exporter or a Slack alert.

Full-text search across every session you’ve ever had

The other killer feature, and the one I personally got the most value out of: Cmd+K in the web UI does SQLite FTS5 search across every message in every session from every agent. “what did I do with the Stripe webhook handler last March?” returns results from your Claude Code session, your Codex transcript, and your Cursor edits, all in one ranked list.

Other navigation:

j / k — move between sessions (Vim-style)
[ / ] — page through messages within a session
? — show all keyboard shortcuts
Sessions can be exported as HTML or published to a GitHub Gist with one click

There’s also a live SSE channel so sessions you’re actively running show new messages as they arrive — useful if you’ve got a long-running Codex agent in another tab and want to watch its progress without alt-tabbing.

What the dashboard actually shows

agentsview stats     # human-readable summary over last 28 days

Output is a structured analytics report with:

Session archetypes — automation vs quick vs standard vs deep vs marathon, based on duration + message count + tools-per-turn
Cache economics — how much you saved (or didn’t) from Anthropic’s prompt cache
Tool / model / agent mix — which tools you actually use vs which you installed and forgot
Temporal heatmap — your coding activity by hour-of-day and day-of-week
Peak context tokens — how close you got to the model’s window in each session
Opt-in git outcomes with --include-git-outcomes (commits / LOC / files changed per session)
Opt-in GitHub PR outcomes with --include-github-outcomes (calls gh to count merged PRs)

The git/GitHub outcomes are off by default because they’re slow on large repos, but they’re the part that turns “I spent 12 hours in Claude Code last week” into “I spent 12 hours in Claude Code last week and shipped 7 PRs across 3 repos.” That’s the metric that matters.

The JSON output is versioned (schema_version: 1), which is the kind of detail that tells you this project is built for downstream consumers — you can pipe it into Grafana, into a status bar plugin, into a weekly self-review email — without worrying about breakage.

The full supported-agent list

agentsview auto-discovers sessions from all of these on first run:

Agent	Session directory
Amp	`~/.local/share/amp/threads/`
Antigravity	`~/.gemini/antigravity/`
Antigravity CLI	`~/.gemini/antigravity-cli/`
Claude Code	`~/.claude/projects/`
Claude Cowork	`~/Library/Application Support/Claude/local-agent-mode-sessions/`
Codex	`~/.codex/sessions/`
Copilot CLI	`~/.copilot/`
Cortex Code	`~/.snowflake/cortex/conversations/`
Cursor	`~/.cursor/projects/`
DeepSeek TUI	`~/.codewhale/sessions/`, `~/.deepseek/sessions/`
Forge	`~/.forge/`
Gemini CLI	`~/.gemini/`
gptme	`~/.local/share/gptme/logs/`
Hermes Agent	`~/.hermes/sessions/`
iFlow	`~/.iflow/projects/`
Kilo	`~/.local/share/kilo/`
Kimi	`~/.kimi/sessions/`
Kiro CLI / Kiro IDE	`~/.kiro/sessions/cli/`, `~/Library/Application Support/Kiro/`

That’s already comprehensive, and the project is adding new agents fast — the commit history shows a typical week ships support for 1–2 more.

Remote access (the part most people get wrong)

agentsview binds to 127.0.0.1 only and validates the request Host header to protect against DNS-rebinding attacks. That’s correct security defaults, but it means that if you try to reach it over SSH port forwarding or from a remote dev environment (exe.dev, Codespaces, Coder, WSL2), API calls get rejected with 403 Forbidden.

The fix is documented and clean:

# Browser opens http://127.0.0.1:18080 via `ssh -L 18080:127.0.0.1:8080 host`
agentsview serve --public-url http://127.0.0.1:18080

# Browser opens a forwarded hostname like https://your-workspace.exe.dev
agentsview serve --public-url https://your-workspace.exe.dev

For any setup that genuinely exposes the UI beyond loopback, also pass --require-auth. The Docker compose example explicitly publishes only on 127.0.0.1 for the same reason.

Honest limitations

A few caveats before you brew install --cask:

SQLite is fine until it isn’t. The default backend works for tens of thousands of sessions. If you’re an enterprise team mirroring sessions from multiple machines, agentsview supports a PostgreSQL backend (PG_SERVE=1, AGENTSVIEW_PG_URL=...) and an experimental DuckDB mirror with a “Quack” remote-query layer. Those are documented but newer; expect rough edges if you’re the first person at your company to use them.

Containerized sessions only see what you mount. If you run agentsview in Docker, it can only discover the agent directories you explicitly mount as volumes. Forget to mount Codex, and Codex won’t appear in the UI. The README is clear about this — but it bit me the first time, so worth flagging.

Git outcomes are opt-in for a reason. --include-git-outcomes runs git log and git diff --shortstat across your repos to attribute LOC changes to sessions. On a 100K-file monorepo this is slow. Don’t enable it by default; run it on a cron once a day if you want the data.

Per-session cost can be null for new models. Pricing comes from LiteLLM’s rate table. If you’re using a freshly released Anthropic or Bedrock model that LiteLLM hasn’t picked up yet, has_cost will be false and the cost column will be empty for those sessions. The fix is upstream — pip install -U litellm and re-run.

Docker container runs as root. The default image runs as root, which is fine inside a container but means bind-mounting /data to your host home directory creates root-owned files. Prefer named volumes, or pre-create the directory with the ownership you want.

FAQ

Q: How does this compare to ccusage? ccusage is Claude-Code-only and re-parses JSONL on every invocation. agentsview covers 20+ agents, indexes once into SQLite, and queries are ~100× faster. The cost math is also more accurate because agentsview separates cache-creation tokens from cache-read tokens; ccusage doesn’t. If you only use Claude Code, ccusage is fine. If you use anything else alongside it, switch.

Q: Does it phone home or upload my session data anywhere? No. The binary binds to 127.0.0.1, there are no accounts, no telemetry, and no cloud component. Everything lives in ~/.agentsview/sessions.db. The optional GitHub Gist export only runs when you click “publish” on a specific session.

Q: Will it work with self-hosted models (Ollama, vLLM, LM Studio)? Sessions from agents that talk to self-hosted models still get indexed — the message content, tool calls, and metadata all show up. Cost tracking won’t return USD figures for them (since the models are free), but token counts and session structure are fully captured.

Q: Can I use it on a server that runs my CI agents? Yes. The standalone agentsview usage daily --json mode doesn’t require the server — you can SSH into a build box, run it, and pipe the JSON into Prometheus or a Slack webhook. If you want the web UI on a CI host, run with --require-auth and --public-url set to the hostname.

Q: What happens to my data if I uninstall? The session files in ~/.claude/projects/ etc. are owned by the agents themselves, not by agentsview — uninstalling agentsview leaves them untouched. The only thing you’d delete is ~/.agentsview/ (the SQLite index and logs).

Q: Is there an MCP server so agents can query their own history? Not yet, but it’s the obvious next step and there’s an open issue for it. For now, agents can hit the REST API at http://127.0.0.1:8080/api/v1/sessions/... if you want to wire it up manually.

Bottom line

agentsview is the rare GitHub-trending repo that solves an actually-painful problem and is engineered like a finished product, not a weekend hack. The default security posture is correct (loopback + Host validation). The CLI is scriptable and the JSON output is versioned. The cost math models prompt caching properly. The session-archetype analytics turn raw usage data into something you can reason about.

If you use more than one AI coding agent — and in mid-2026 that’s most people — install it today: brew install --cask agentsview, then agentsview serve --background. The dashboard at http://127.0.0.1:8080 will pay for itself the first time you ask “what was I doing in Codex three weeks ago?” and get an answer in one keystroke.

Repo: github.com/kenn-io/agentsview. Docs and screenshots: agentsview.io. MIT licensed, Go, one binary. At 1,382 stars added this week, it’s on track to be the default cross-agent session viewer of the year.