# agentsview: local session search and token cost tracking for Claude Code, Codex and 20+ agents

> agentsview is a single Go binary that discovers coding-agent session files on your machine, syncs them into a local SQLite database and serves a web UI on 127.0.0.1:8080. It is worth adopting if you want searchable history and cost numbers without sending transcripts to a hosted service, and it is the wrong tool if you need a hosted, multi-tenant dashboard.

**kenn-io/agentsview** — Local-first session search, analytics, insights, and token use statistics for coding agents, supporting Claude Code, Codex, and more than 20 other agents.

- Repository: https://github.com/kenn-io/agentsview
- Website: https://agentsview.io
- Stars: 5,992 · Forks: 679
- Language: Go
- License: MIT
- Published: 2026-08-04 · Updated: 2026-08-18 · Language: en
- Canonical page: https://hysenlabs.com/projects/kenn-io-agentsview

## What agentsview solves for people running several coding agents

Coding agents write their session history to per-agent directories in formats that have nothing to do with each other. Claude Code keeps its own project layout, Codex keeps another, and the README's Docker example mounts both `$HOME/.claude/projects` and `$HOME/.forge` as separate roots. Once you use more than one agent, the history is scattered, and answering a question like "which session was that refactor in" or "what did this month cost" means opening each tool in turn.

agentsview is the layer that reads those directories, syncs them into one local SQLite database, and puts search, analytics and token-use statistics on top. The README describes it as a fast, local replacement for ccusage and similar tools for the usage side. The audience is a developer or small team on one machine or one server, not a platform team building a shared internal service: there are no accounts, and the default bind is loopback.

## How the daemon, SQLite archive and web UI fit together

The architecture has three parts. A writable SQLite database is the archive. A detached local daemon owns writes to it and is shared with the desktop app. A web server exposes the UI and API, binding to loopback and validating the request `Host` header against DNS-rebinding attacks.

The read/write split is the interesting design choice. Read-only CLI commands attach to the daemon when it is already running, but fall back to direct read-only SQLite access on a cold archive so one-off scripts stay fast. Commands that need fresh data or need to write, such as `sync`, `usage`, `token-use`, `pg push` and `duckdb push`, auto-start the daemon when needed. Background daemons self-exit after an idle period unless a client request or a daemon-owned job is active, so the process does not sit resident forever.

Storage is not limited to SQLite. The repository's `go.mod` pulls in both `mattn/go-sqlite3` and `modernc.org/sqlite`, plus `duckdb-go/v2` and `pgx/v5`, which matches the README's PostgreSQL and DuckDB mirror paths. For remote agents, Claude and Codex sources can be configured as `s3://` roots; agentsview lists object metadata and downloads only changed sessions, using size, modified time and fingerprints such as ETag, version ID or checksums to decide what changed.

## Installing agentsview and running a first sync

On macOS and Linux the README gives a single install script. It downloads the binary; there is no package manager step required for the CLI path.

```bash
curl -fsSL https://agentsview.io/install.sh | bash
```

Windows users get a PowerShell equivalent, and there is a desktop app for macOS and Windows available from GitHub Releases or through Homebrew as a cask.

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

After install, the README's quick start is a sequence of subcommands rather than a config file. `serve` runs the server in the foreground, `daemon start` starts the writable SQLite daemon, and `session list` reads from the daemon if it is warm and otherwise from SQLite.

```bash
agentsview serve           # start the server in the foreground
agentsview daemon start    # start the writable SQLite daemon
agentsview daemon status   # show daemon status
agentsview session list    # read from the daemon if warm, otherwise SQLite
agentsview usage daily     # print daily cost summary
```

On first run, according to the README, agentsview discovers sessions from every supported agent on the machine, syncs them into the local database, and serves the web UI at `http://127.0.0.1:8080`. If you reach it through SSH port-forwarding or a remote dev environment, the `Host` header check rejects API calls with `403 Forbidden` until you restart the server with `--public-url` set to the exact origin in your browser.

```bash
agentsview serve --public-url http://127.0.0.1:18080
```

## The container only sees agent directories you mount

The Docker path is the clearest limitation in the README, and it is stated plainly: a containerized agentsview instance can only discover agent sessions from directories you explicitly mount into the container. If you do not mount an agent's session directory and point the matching environment variable at it, that agent will not appear in the UI. A host install discovers everything by default; a container discovers exactly what you configure, and the failure mode is silence rather than an error.

The published image defaults to `agentsview serve`, and `PG_SERVE=1` switches the startup command to `agentsview pg serve`. The included `docker-compose.prod.yaml` persists the data directory in a named volume and mounts Claude, Codex, Forge and OpenCode session roots read-only. The README notes the container runs as root and recommends a named volume for `/data` over a host bind mount, or pre-creating a bind-mounted directory with the desired ownership, to avoid root-owned files in your home directory.

Exposure is the other boundary. The examples publish the UI on `127.0.0.1` only, and the README says to enable `--require-auth` if you need to expose it beyond localhost. The Quack example carries the same warning: plain HTTP Quack on a non-loopback bind requires `--allow-insecure` and should only be used behind a trusted tunnel or reverse proxy.

## agentsview compared with ccusage and hosted analytics

The README positions `agentsview usage` as a fast, local replacement for ccusage and similar tools. The difference in approach is scope. A usage-only tool answers the cost question and stops there; agentsview syncs full session records into a database, so search across sessions and the cost summary read from the same archive. If cost reporting is all you need, a narrower tool has fewer moving parts: no daemon, no SQLite archive, no web server to bind and secure.

Against a hosted analytics service the trade is inverted. A hosted product can aggregate across a team without anyone mounting directories or opening ports, and it can keep history when a laptop is replaced. agentsview keeps transcripts local by default and has no account model, which also means there is no server-side aggregation to fall back on. The S3 roots are the middle path: a central agentsview instance can read sessions that other machines push to S3-compatible object storage, but each machine still has to push them.

The release cadence is visible in the repository: v0.40.1 on 2026-08-04, v0.41.0 on 2026-08-17 and v0.41.1 on 2026-08-18, with the last push on 2026-08-18. That is a project shipping frequently, and it also means the CLI surface can move between minor versions.

## Licence, upgrade cost and what to check before adopting

agentsview is MIT licensed, which permits commercial use and modification with the usual requirement to keep the copyright and permission notice. That is a permissive licence with no copyleft obligation on your own code. It says nothing about the licence of the agent session data you point it at, and the README warns not to paste tokens, OAuth files or other secrets into bug reports; the Devin CLI integration deliberately ignores copied config and OAuth paths. This is a description of the licence text, not legal advice.

Upgrade cost is mostly operational. The daemon is a detached process that self-exits when idle, so an upgrade means stopping or restarting it rather than replacing a library. `agentsview daemon restart` restarts from current configuration, and the README notes that `daemon start` and `daemon restart` accept no serve-specific flags; use `agentsview serve --background` when a one-off daemon needs a serve-only flag such as `--no-sync`. The Docker image is tagged `latest` in every README example, so pinning a version is a decision you make yourself.

The build is not trivial if you compile from source. The Makefile and Dockerfile both compile sqlite-vec's cgo bindings against the header of the SQLite amalgamation that `mattn/go-sqlite3` bundles, and both warn that setting `CGO_CFLAGS` replaces Go's default `-O2 -g`, which leaves the amalgamation unoptimized and, per the Makefile comment, produces 2-3x slower queries. That is a build-system constraint worth knowing before you vendor the project.

## Conclusion

Adopt agentsview if you already run Claude Code, Codex or the other supported agents on one machine and want session search plus daily cost numbers that never leave it; the Docker path is the right choice for a server that collects sessions mounted read-only from several agent roots. Do not adopt it if you need a hosted, multi-tenant dashboard or if you are unwilling to mount each agent's session directory explicitly, because a container only sees what you mount. Before rolling it out, verify the two things the README leaves open: that the daemon actually starts and reports healthy on your platform, and that every agent you rely on is discovered after the first sync.

## FAQ

### What is agentsview?

It is a local-first tool that browses, searches and tracks costs across AI coding agents. The README describes one binary, no accounts, everything local, with sessions synced into a local SQLite database and a web UI served at http://127.0.0.1:8080.

### How do I use agentsview with Claude Code?

agentsview discovers Claude Code sessions from the local session root on first run, and the Docker examples mount $HOME/.claude/projects read-only with CLAUDE_PROJECTS_DIR pointing at the mounted path. Claude sources can also be configured as s3:// roots in claude_project_dirs so a central instance reads sessions other machines push to object storage.

### What is agentsview?

The repository is kenn-io/agentsview, a Go project under the MIT licence supporting Claude Code, Codex and more than 20 other agents. It ships a CLI, a desktop app for macOS and Windows, and a published Docker image at ghcr.io/kenn-io/agentsview.

## Sources

- [Official documentation](https://agentsview.io)
- [Official README](https://github.com/kenn-io/agentsview#readme)
- [Project repository](https://github.com/kenn-io/agentsview)
- [Release notes](https://github.com/kenn-io/agentsview/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/kenn-io-agentsview