Local only · Read only · Open source

Your agent's context window is a black box. Open it.

ContextClues reads a running Claude Code session on your own machine and shows exactly what is in its context window, what is filling it, and how much working room is left before it compacts.

Nothing is uploaded. Nothing is modified. Every number is labeled with how it was obtained.

$ npx contextclues
● No cloud ● No account ● No telemetry ● Never writes to ~/.claude

⇆ Scroll sideways to explore the full dashboard

The full case file. One session, live, on localhost.

The problem

You find out the window was full after it costs you.

A long agent session fills its context window quietly. There is no gauge, no breakdown, and no warning. One accidental read of a lockfile can take a third of the window, and nothing tells you it happened. You are steering a process whose most important state variable is invisible.

When the window fills, the session compacts. Older material is summarized away and dropped. Work you assumed was still in context is gone, and the only signal is the agent starting to behave as if it forgot something. By then you have already paid for it: a repeated explanation, a wrong answer you trusted, a debugging cycle chasing a problem that was never in the code.

ContextClues turns that black box into an instrument panel. It runs beside your session and answers the questions you currently have to guess at: how full is the window, what is taking up the room, what did compaction actually drop, and how long can I keep going.

How it works

It reads the files the agent already writes.

Claude Code keeps a registry of running sessions and an append only transcript of every event on local disk. ContextClues watches those files, tail parses the transcript incrementally, indexes it into a local database, and streams updates to the dashboard over server sent events. Claude's files are opened read only and are never modified.

It deliberately does not install an agent hook. A hook would give push style events, but installing one edits your configuration, and this tool does not change your setup without being asked.

~/.claude/sessions/*.json      ──┐                          ┌─ local SQLite
~/.claude/projects/**.jsonl    ──┤──► collector ──►──┤
settings, .mcp.json, plugins   ──┘    read only          └─ event bus ─► SSE ─► dashboard
What it shows

Seven panels, one case file.

Every session is a case file. Context entries are evidence. What the tool notices, it files as clues.

Context Meter

Tokens in the window from the API's own count, as a share of maximum, with cache breakdown and observation age.

Context Trajectory

Growth across every API request, with burn rate, projected runway in time and requests, and compaction boundaries marked.

Composition

What is occupying the window, stacked by source: your messages, replies, tool results, injected context, and system overhead.

Evidence

Every transcript record, searchable, with size, age, whether it is still in context, and why it is believed to be there.

Tool Registry

Every known tool with its provider, its status, where that knowledge came from, and how many times it was actually used.

Live Activity

Tool calls, file reads, results, compactions, and tool availability changes, streaming in as they happen.

Clues

Oversized results, files read repeatedly, exact compaction drops, unused tools, window pressure, and stale heavy entries.

Local and safe

Your transcripts never leave the machine.

This tool reads the most sensitive text on your computer: your code, your prompts, and your command output. It is built so that none of it goes anywhere.

No network

No cloud service, no account, no authentication, no telemetry. The server binds the loopback interface, so it is not reachable from your local network.

Read only

Claude's session files are opened read only and are never written to. Nothing under your agent's configuration directory is created, edited, or deleted.

Secrets redacted

API keys, tokens, JWTs, private keys, and secret style environment assignments are detected and scrubbed before any preview is stored or rendered.

Disposable state

The tool's own index lives in a local folder you can delete at any time. It rebuilds itself from the transcripts on next run.

Where the numbers come from

Every number says how it was obtained.

A context dashboard is only useful if you can tell measurement from guesswork. Some of these figures are genuinely knowable and others are not, so nothing is presented as plain fact. Every value carries one of four confidence labels, visible in the interface, so you always know which one you are reading.

Observed
Read directly from the agent's own artifacts: per turn token usage, compaction records with exact before and after totals, and tool availability changes. The growth curve and burn rate are observed.
Estimated
Per entry sizes, using a characters divided by four heuristic. The transcript stores content, not per message token counts, so entry sizes are always approximations and are always marked as such.
Inferred
Derived indirectly. System prompt overhead is the observed total minus the sum of estimates. Runway is inferred, because it extrapolates observed data forward, so the interface says "projected" and never says "will".
Assumed
Static mappings that cannot be verified locally, such as which maximum context window a given model has. No local file exposes it, so it is mapped and labeled rather than presented as known.

The same care goes into the projection. Growth per request is strongly right skewed: most requests add a little, and an occasional large file read adds a lot. Runway is a question about cumulative growth, so the projection is driven by the mean rather than the median, because the mean counts large requests at the rate they actually occur. A median would describe a typical request while systematically under predicting how fast the window fills. The panel reports both, and when the average sits far above the typical request it says the session is spike dominated and widens the runway into a range.

ContextClues never claims access to the model's hidden reasoning, and it does not pretend to know exactly which messages survive between compactions. That is inference, and it is labeled as inference.

Install

One command, no services, no config.

Run it. Then start a Claude Code session in another terminal and it appears automatically.

# requires Node.js 22.13 or newer
$ npx contextclues

→ http://localhost:4310

# or install it permanently
$ npm install -g contextclues
Questions

The four things people ask first.

Does ContextClues send my code or prompts anywhere?
No. Everything stays on your machine. There is no cloud service, no account, no authentication, and no telemetry. The dashboard runs on localhost and the process makes no outbound calls. This website is separate from the tool and uses cookieless analytics that set no cookies and store no personal data. See the privacy page.
Does it modify my Claude Code configuration?
No. Claude's session files are opened read only and are never written to. ContextClues deliberately does not install an agent hook, because installing one would edit your configuration without being asked.
How accurate are the token numbers?
Every number carries a confidence label. Observed values are read directly from the API usage counts Claude Code records per assistant turn. Per entry sizes are estimated with a characters divided by four heuristic. System prompt overhead and runway are inferred. The maximum context window is assumed, because no local file exposes it.
What do I need to run it?
Node.js 22.13 or newer, and a machine where Claude Code has run. It uses the built in SQLite module, so there is nothing to compile. Run npx contextclues, or install it permanently with npm install -g contextclues.

You cannot manage a context window you cannot see.

GET CONTEXTCLUES →