For months we’ve talked about agents as if the main problem was choosing one.
Claude Code or Codex. OpenCode or Gemini CLI. Copilot or Cursor. The debate focused on benchmarks, user experience, and output quality. But when a team starts using multiple agents every day, a much more uncomfortable question appears:
What are they actually doing?
Not in the abstract. Not in a demo. On your machine, in your repos, in your actual sessions.
How much did that refactor cost? Which agent did you use most this week? Which one got stuck? Which sessions ended well and which were abandonment disguised as progress? Where’s that conversation where you discussed an architecture decision two months ago?
kenn-io/agentsview exists to answer exactly that.
AgentsView is a local-first app for navigating, searching, and analyzing coding agent sessions. It reads the files that tools like Claude Code, Codex, OpenCode, Gemini CLI, Copilot CLI, Cursor, Kiro, OpenHands and many others leave on your machine, indexes them in SQLite, and gives you a web or desktop interface to explore them.
The short way to understand it is this:
AgentsView is observability for your work with agents.
It doesn’t observe servers. It doesn’t observe APIs. It observes the new unit of work that’s emerging in engineering teams: the agentic session.
Why this matters now
The first stage of coding agent adoption was individual.
A dev installed Claude Code, tried Codex, played with OpenCode, and decided which one they liked best. Productivity was a feeling. “It helps me a lot”, “it makes fewer mistakes”, “it saves me time”.
That’s enough for personal adoption.
It’s not enough for Platform Teams.
When a team starts relying on agents for reviews, migrations, refactors, test generation, or bug exploration, you need more than intuition. You need traceability.
AgentsView aims at that gap.
It doesn’t replace the agent. It doesn’t try to be another runtime. It’s not a framework for building agents. It’s a back-layer: it takes what already happened, organizes it, and makes it queryable.
That distinction matters. Many agentic tools want to be in the critical path. AgentsView, at least by design, can start as a read-only tool. It watches your local sessions, indexes them, and lets you understand patterns without forcing you to change agents.
What AgentsView does
The most obvious function is the session browser.
You open AgentsView and can browse conversations from different agents in a single interface. You see prompts, responses, tool calls, thinking blocks when they exist, code, errors, and session evolution. You can also filter by project, agent, date, or message volume.
That alone solves a concrete pain: your agentic sessions today are scattered.
Claude Code has its own structure. Codex has another. OpenCode has another. Gemini has another. Cursor has another. Each tool stores history its own way. AgentsView tries to convert that chaos into a common operational record.
The second key function is full-text search.
This seems minor until you need it. In daily work with agents, many important decisions get buried in conversations: why a strategy was rejected, what error appeared during a migration, which file was the bottleneck, what command fixed a problem. AgentsView indexes the content and lets you search across past sessions.
In practice, it converts your agentic history into engineering memory.
Not memory for the model.
Memory for the team.
Costs: the missing dashboard
The most interesting part for mature teams is token and cost tracking.
AgentsView includes commands like:
agentsview usage daily
agentsview usage daily --breakdown
agentsview usage daily --agent claude --since 2026-04-01
agentsview usage statusline
The idea is simple: if your agents already log token usage, AgentsView reads it, normalizes it, and converts it into cost reports.
This matters because the era of “AI all-you-can-eat” is closing. More and more teams need to understand how much they spend on agents, which workflows burn the most tokens, and where consumption is concentrated.
AgentsView isn’t limited to Claude Code. The project declares cost coverage for Claude Code, Codex, Copilot CLI, OpenCode, Pi, Gemini, and Hermes, with more agents coming as their parsers can extract usage data.
That makes it more interesting than a tool specific to Claude. The coding agent market is fragmenting, and teams probably won’t use just one agent. They’ll use several.
That’s when AgentsView starts to look less like a viewer and more like a FinOps layer for AI-assisted development.
Session Intelligence: not all sessions are equal
Another important piece is Session Intelligence.
AgentsView doesn’t just show sessions. It tries to classify them.
It calculates health signals per session: outcome, tool failures, retries, edit churn, context pressure, and compactions. Then it assigns a score and a grade. The project itself clarifies that these are heuristics, not absolute truth, and that’s correct. But as a triage tool, the approach makes a lot of sense.
An example:
A long session wasn’t necessarily productive.
It could have been long because the agent advanced autonomously. Or it could have been long because it repeated commands, edited the same file too many times, failed tools, and lost context midway through the work.
AgentsView tries to separate those two stories.
For a Staff Engineer, this is useful because it lets you detect patterns:
- what type of task produces fragile sessions,
- which agent tends to enter loops,
- which repos generate more tool failures,
- where compactions interrupt real work,
- which sessions look complete but had a lot of rework.
That kind of data changes the conversation.
You’re no longer debating “agent X is better than Y” in the abstract. You can look at real sessions by project and by workflow.
Installation
The simplest installation on macOS is via Homebrew:
brew install --cask agentsview
You can also install via pip or run directly with uvx:
pip install agentsview
uvx agentsview
On macOS and Linux there’s also the shell installer:
curl -fsSL https://agentsview.io/install.sh | bash
On Windows:
powershell -ExecutionPolicy ByPass -c "irm https://agentsview.io/install.ps1 | iex"
Then:
agentsview serve
That starts the local server and opens the web UI. By default it runs locally, indexes sessions in a SQLite database, and serves the interface from your machine.
You can also run it on a different port:
agentsview serve --port 9090
Or prevent it from automatically opening the browser:
agentsview serve --no-browser
For remote teams or environments, the repo includes options with Docker and PostgreSQL. Docker mode allows mounting session directories as read-only, and PostgreSQL Sync allows pushing data to a shared database for team dashboards or multi-machine setups.
What agents it supports
AgentsView declares support for a wide range of agents and tools, including:
- Claude Code
- Codex
- Copilot CLI
- Gemini CLI
- OpenCode
- OpenHands CLI
- Cursor
- Amp
- Zencoder
- Zed
- VS Code Copilot
- Pi
- Qwen Code
- Kimi
- Kiro CLI
- Kiro IDE
- Forge
- Warp
- Positron Assistant
- Antigravity
- Antigravity CLI
Not all have the same level of data. Some provide complete transcripts. Others provide partial metadata. Some contribute to cost tracking and others don’t yet. But the project’s direction is clear: be a multi-agent viewer, not an extension of a single tool.
That positioning is key.
If Claude Code becomes the premium agent, Codex the integrated agent, OpenCode the hackable agent, and Gemini the agent tied to the Google ecosystem, someone has to help compare the work they produce. AgentsView wants to occupy that space.
Real-world use cases
1. Recover technical decisions
You’re looking for an old conversation where the agent investigated a migration, explained why a certain approach failed, or documented a rare bug.
Instead of relying on human memory or infinite scrolling, you search by function, error, file, or concept.
2. Measure spending per agent
You want to know how much it cost to use Claude Code versus Codex or OpenCode over the last few weeks.
AgentsView allows daily reports, breakdown by model, and filters by agent or date.
3. Detect expensive workflows
Not all costs come from “using a lot of AI”. Sometimes they come from a poorly designed workflow.
An agent that loads too much context, repeats commands, or gets stuck in edit cycles can be more expensive than useful. The usage dashboard helps you find those outliers.
4. Compare agents with real data
Instead of asking which agent “feels better”, you can look at metrics per agent: sessions, messages, duration, tool usage, costs, and health signals.
It doesn’t replace technical judgment, but it improves the conversation.
5. Audit sensitive sessions
In environments where agents work on critical code, having navigable history helps answer what was done, what commands were executed, and what files were touched.
It’s not a complete compliance solution, but it’s a step toward traceability.
6. Build team habits
A Platform Team could review weekly:
- most expensive sessions,
- sessions with the most failures,
- projects with highest consumption,
- most-used agents,
- tasks that should be automated without LLMs,
- tasks that justify premium models.
That ritual looks a lot like FinOps, but applied to coding agents.
The local-first aspect is not decorative
AgentsView insists that everything runs locally by default: SQLite, embedded frontend, no accounts, and no mandatory cloud services.
This is not a minor detail.
Coding agent sessions can contain prompts, internal paths, code snippets, customer names, production errors, commands, accidentally exposed secrets, or architecture decisions. Uploading that to another SaaS just to have analytics can be hard to justify.
The local-first approach lowers the adoption barrier.
You can try it without asking procurement, without opening an account, and without moving your history to a third party. Later, if the team needs to share data, PostgreSQL Sync exists as a deliberate option.
That’s the correct architecture for this category.
Local first.
Shared later, if needed.
Where you still need to be careful
AgentsView is powerful, but don’t oversell it as magic.
First, it depends on what agents store. If a tool doesn’t record tokens, tool calls, or transcripts with enough detail, AgentsView can’t invent that information.
Second, health metrics are heuristics. They’re useful for detecting patterns, not for automatically declaring whether a session was good or bad.
Third, cost tracking is still maturing. Even the documentation treats it as a new area. That doesn’t invalidate it, but it means you should use it as a directional instrument, not as perfect financial accounting.
Fourth, for team use there are operational questions: where PostgreSQL is stored, who can see what sessions, how to filter sensitive information, and what internal policies apply.
The tool solves visibility. Governance is still the team’s work.
Why it could become important
AgentsView appears at a specific moment in the market.
Coding agents are stopping being personal toys and starting to become engineering infrastructure. When something becomes infrastructure, it needs observability.
It happened with servers.
It happened with containers.
It happened with CI/CD.
It happened with cloud costs.
Now it’s starting to happen with agents.
The difference is that the unit being observed is no longer just a request, a pod, or a job. It’s an operational conversation between a human, a model, and a set of tools with permissions over a repository.
That requires a new interface.
AgentsView doesn’t have to win by having the best agent. It wins if it becomes the place where you understand what all your agents did.
And that category could be huge.
The reading for Platform Teams
If your team is using a single agent casually, AgentsView can seem like a convenient viewer.
If your team is using multiple agents across multiple repos, it starts to seem necessary.
The question Platform Teams should ask themselves is not “do we need another tool?”.
It is:
Do we have any systematic way to observe our agentic work?
If the answer is no, AgentsView deserves a try.
Not because it’s going to solve all AI governance. It won’t.
But because it changes the starting point. It lets you stop discussing agents from anecdotes and start discussing them from real sessions, real costs, and real patterns.
In the era of coding agents, that visibility is going to stop being a luxury.
It’s going to be part of the stack.
Quick commands
# Install on macOS
brew install --cask agentsview
# Install via pip
pip install agentsview
# Run without installing
uvx agentsview
# Start local UI
agentsview serve
# View daily costs
agentsview usage daily
# View costs by model
agentsview usage daily --breakdown
# Filter by agent and date
agentsview usage daily --agent claude --since 2026-04-01
# View summary for statusline
agentsview usage statusline
# View health of recent sessions
agentsview health
# Aggregated statistics
agentsview stats
aiagents claudecode codex opencode #DeveloperTools #PlatformEngineering llmops devex #AIEngineering finops