How are the token counts calculated, and are they exact?

They are estimates, computed in your browser and never sent anywhere to be produced. Each file is split into fenced or indented code and ordinary prose; code is costed at characters divided by four and prose at words times 1.3, which is the heuristic the source skill prescribes. MCP tool schemas are costed at about 500 tokens per tool. A real tokenizer would differ by a few percent, but the ranking of what is expensive - which is what you act on - is stable.

Does anything leave my machine?

Not until you press Run the audit. Dropping files reads them with the browser's FileReader; the whole inventory, the flags and every token count are computed locally, and the free measurement is complete on its own. When you do run, the measurements are sent along with a budgeted excerpt of each file - large files go head-and-tail with the middle marked - and the app tells you on screen exactly how many characters were profiled locally versus sent.

What stops the model from inventing token savings?

The browser checks its arithmetic. Every component the model names must exist in the inventory the scanner built; a recommendation that claims to save more tokens than the component it names actually costs is flagged; and the total overhead the model reports is compared against the measured figure. Any disagreement is shown as a cross-check panel above the results rather than being rendered as fact.

Why do MCP servers dominate my budget?

Because every tool a connected server exposes ships its JSON schema into the session and stays there. At roughly 500 tokens per tool, a single 30-tool server costs about 15,000 tokens - typically more than every skill and agent combined. Servers that wrap a command-line tool the agent could simply run are flagged specifically, since disconnecting one is usually the largest single win available.

What does an audit cost, and can I try it without signing in?

The measurement is free and always runs in your browser. The audit is metered: a worst-case amount is reserved before the run and only what the run actually uses is charged, with both shown on the meter beside the button. Three bundled examples - a lean setup, a sprawling one and an over-budget one - replay their saved results in full for free without signing in, so every verdict is reachable at zero cost.

Context Lens — drop your agent config, get the context-budget audit

Your agent configuration

Drop your .claude folder here — or the loose files.

Your sub-agent and skill definitions, your rule and command files, the MCP config (.mcp.json), and the top-level project-convention file your assistant reads on every turn. Everything is read in your browser with no upload; the whole measurement below is free and complete on its own.

Choose files Choose a folder

Or paste one file Handy when you only want to check the memory file or the MCP config.

Path or filename

Name this setup — used to compare against your last audit

Context window

What is this project? — optional; decides what counts as relevant

MCP tools in total — optional; from /mcp

The audit

The budget

Cross-check against the browser's measurements

Executive summary

Assumptions & open questions

What to change

Ranked by tokens recovered. Every figure is checked against the measured cost of the component it names.

Issues

Where the tokens go Measured in your browser, not reported by the model.

Kind	Count	Tokens	Share of overhead	Share of window

MCP servers

Server	Command	Tools	Tokens	Tier	Note

Every component Tier comes from the audit; every other column is measured locally.

File	Kind	Lines	Tokens	% of window	Desc words	Tier	Flags

Worth keeping

Measurement coverage

Next steps

Summary

Result

How it works

Nothing to hand? Load the — a tight setup that comes back healthy — the , where a long memory file, two overlapping rule files and a couple of CLI-wrapping MCP servers are quietly eating the window, or the , where thirteen servers and a duplicated skill directory have taken a third of the context before anyone types.

Drop the config — the measurement is free

No upload, no AI. Every file is classified as a memory file, agent, skill, rule or command; its tokens are estimated by splitting fenced and indented code (chars ÷ 4) from prose (words × 1.3); its YAML frontmatter is parsed, including the folded block form, so the description that rides along on every Task call gets a word count. .mcp.json becomes servers with tool-schema overhead at about 500 tokens per tool, with CLI-wrapping servers named. Byte-identical files across mirrored skill directories are found and counted once, and always-on files that repeat each other are flagged by trigram overlap. This part costs nothing and stands on its own.

The AI audits — this is the metered part

The model gets the browser's exact numbers plus a budgeted excerpt of every file — large files head-and-tail with the middle marked, never a blind cut — and returns the judgement the arithmetic cannot: every component classified always, sometimes or rarely needed against your project, the issues that actually matter, and a ranked list of trims. Then the browser marks its homework: a saving larger than the component it names actually costs, a component that is not in your inventory, or a total that disagrees with the measurement all get surfaced above the results. Pricing is honest too — a worst-case amount is reserved and only what the run uses is charged.

Trim, then audit again

The number that matters is the second one. Take the top recommendations, drop the folder again, and the header states the delta — tokens recovered and the change in share of window — against your last audit of the same setup. Export the component table as CSV for a spreadsheet, the report as Markdown for a PR description, or JSON for a script. Past audits live on your SkillSafe account, so the comparison works from your laptop and your desktop alike.

A derived work of the context-budget skill by affaan-m (MIT), which defined the inventory, the thresholds and the report this app is built around.