How I Built a Local Explorer for Six AI Coding Agents.

Vladislav Ramazaev — Wed, 24 Jun 2026 22:00:00 +0000

AI coding agents are becoming a normal part of software engineering, but their history is still surprisingly difficult to work with.

A session usually lives inside one specific tool. Once it becomes long, gets archived, or you switch to another agent, finding an earlier decision, command, error, or code change becomes unnecessarily difficult.

I originally built Claudescope as a small viewer for my Claude Code sessions.
It has since grown into a local, read-only explorer for sessions produced by six coding agents:

Claude Code
OpenAI Codex
JetBrains Junie
pi
opencode
GitHub Copilot CLI

The project is open source and available on GitHub github.com/vladar107/claudescope

The problem with coding-agent history

Coding agents generate a large amount of useful context:

prompts and responses
commands and tool calls
generated code
file edits
architectural decisions
failed attempts
debugging history
token usage
project memory

However, every agent stores this information differently.

Some use JSONL files. Some use SQLite. Their schemas, directory structures, tool-call formats, and metadata are different.

The data exists, but it is optimized for the agent runtime rather than for a developer trying to answer questions such as:

Why was this implementation chosen?
Which session introduced this change?
What command fixed this issue?
How much did this project cost?
Which agent previously worked in this repository?
What context did the agent preserve for future sessions?

It is possible to search the raw files with grep, but that quickly becomes inconvenient once sessions contain nested tool calls, long outputs, subagents, generated diffs, and several agents using different formats.

From a Claude viewer to a multi-agent explorer

The first version only understood Claude Code transcripts.

Supporting more agents required changing the internal model. Claudescope could no longer treat Claude’s format as the application format.

Instead, each agent now has a connector responsible for:

locating its local session storage
reading it without modifying anything
parsing its native format
converting events into a shared session model
associating sessions with projects

This means a repository touched by Claude Code, Codex, and opencode appears as one project rather than three unrelated histories.

Each session still keeps its agent identity, so sessions can be filtered and compared without losing their origin.

Adding another agent is mostly a matter of implementing another connector rather than changing the rest of the application.

Reading a session as a conversation

Raw transcript files are useful for machines, but not particularly pleasant for humans.

Claudescope renders a session as a threaded conversation with:

Markdown rendering
syntax-highlighted code
tool calls paired with their results
collapsible reasoning and long outputs
subagent and sidechain turns
attachments
token information
command and terminal blocks
syntax-highlighted file diffs

Claude Code slash commands and shell turns are also converted from their raw representation into cleaner command and terminal blocks.

For large sessions, rendering everything at once becomes expensive. Claudescope progressively renders turns and clamps very large tool outputs behind a Show all action.

There is also an in-session search bar. It searches regular messages, collapsed reasoning, tool calls, tool results, and subagent content, then expands the relevant section automatically.

Reviewing what the agent changed

Conversation history is only one side of an agent session. In many cases, the most important output is the set of modified files.

The Files changed view aggregates edits made during a session and presents them more like a code review:

changed-file navigation
per-file additions and deletions
diff statistics
syntax-highlighted red and green diffs
lazily loaded file contents

This is useful when returning to an old session and wanting to understand its actual effect without rereading the full conversation.

It also helps separate what the agent discussed from what it eventually changed.

Searching across all sessions

Claudescope builds a local DuckDB index over normalized session events.

Full-text search uses DuckDB BM25 and works across all supported agents and projects.

Results are grouped by session and include highlighted snippets. Selecting a result opens the original session at the matching message.

This makes the session archive useful as an engineering knowledge base.

For example, I can search for:

an error message I encountered weeks ago
the name of a class an agent refactored
an architectural trade-off discussed in another session
a command that solved a local environment issue
a prompt pattern that produced a useful result

The index is refreshed automatically as new sessions appear.

Agent memory is part of the history

Transcripts are not the only source of agent context.

Different agents also maintain instruction and memory files such as:

CLAUDE.md
AGENTS.md
Copilot instruction files
agent-specific project memory

Claudescope includes a memory browser that presents these files alongside session history.

For Claude Code’s distilled project facts, memory entries can link back to the session that produced them. This provides provenance instead of showing memory as unexplained text.

This became especially useful after adding multiple agents. Instructions and memory are often fragmented across several files, even when they describe the same project.

Continuing an old session

A session viewer should not necessarily become another coding-agent client.

Claudescope remains read-only, but it can generate the appropriate resume or fork command for the original agent CLI.

You can copy the command, return to the terminal, and continue the session in the tool that created it.

This keeps responsibilities separate:

the agent remains responsible for running and modifying code
Claudescope remains responsible for browsing and analysing history

Token, cost, and efficiency analytics

Agent sessions are also operational data.

Claudescope tracks:

input and output tokens
cache reads and cache creation
estimated cost
cost by project
cost by model
cost by agent
activity over time
cache-hit ratios

Pricing can be refreshed from LiteLLM’s community pricing table, while local overrides remain possible.

The newer session-efficiency view ranks sessions by cost and provides context such as:

response count
cost per response
tool-call count
tools per response
cache usage
statistical outlier indicators

This is not intended to declare one agent or session objectively “better.” It makes unusually expensive or tool-heavy sessions easier to identify and investigate.

Exporting and sharing sessions

Sessions can be exported to Markdown for documentation, bug reports, or technical discussions.

Because transcripts may include local paths and credentials, the export flow includes an optional redaction mode for:

home-directory paths
likely secrets
sensitive environment values

Redaction is necessarily heuristic, so exported content should still be reviewed before publishing.

Local and read-only by design

Coding-agent transcripts can contain source code, prompts, file paths, commands, memory, and sometimes secrets.

For that reason, Claudescope runs locally and binds to 127.0.0.1.

It treats every agent source as read-only. Its own persistent state—primarily the DuckDB index and pricing files—is stored separately under ~/.claudescope.

Transcript content is not uploaded to a hosted service.

The server also rejects non-loopback Host headers. Binding to localhost alone does not prevent DNS-rebinding attacks from malicious websites, so the additional host validation protects the local transcript API without introducing a login flow.

The only optional outbound requests are version and model-pricing checks. Neither includes transcript content.

Installation

Claudescope is distributed through npm, Homebrew, and Nix.

npm

Node.js 22.12 or newer is required.

npm install -g @vladar107/claudescope
claudescope

It can also be started without a global installation:

npx @vladar107/claudescope

Homebrew

brew tap vladar107/tap
brew install claudescope
claudescope

Nix

nix run github:vladar107/claudescope

The default command starts the application as a background process and opens it in the browser.

Other lifecycle commands include:

claudescope status
claudescope open
claudescope logs -f
claudescope restart
claudescope stop
claudescope update

What changed after the first release

The initial release was primarily a Claude Code session viewer.

Since then, Claudescope has added:

support for five additional coding agents
unified multi-agent projects
Windows support
Homebrew and Nix installation
better handling of very large sessions
a memory and instruction-file browser
session resume and fork commands
a rebuilt code-review-style Files changed view
Markdown export with optional redaction
live model-pricing updates
session-efficiency analytics

The direction has also changed slightly.

The goal is no longer simply to make individual transcripts readable. It is to make coding-agent history searchable, reviewable, and reusable across tools.

What is next?

There are still many possible directions.

Looking ahead, connectors for more agents are an obvious next step. Beyond that, I’m not entirely sure what should come next — it already covers my own workflow pretty well. I’d really like to hear how others are using their session history and what’s missing for them.

I am particularly interested in how developers use old agent sessions in practice.
Do you return to them to find decisions, prompts, commands, code changes, or something else?

Feedback, bug reports, connector contributions, and pull requests are welcome: Claudescope on GitHub

DEV Community: Vladislav Ramazaev

Want to share one tool I use. Hope, you also can find it useful