Chaser is a 100% local orchestrator that sits between you and the Anthropic API: it routes each task to the cheapest model that can handle it, and hands off context between sessions so you stop re-explaining your codebase every morning. No data ever leaves your machine.
⬇ Free check — Chaser Check Buy Chaser →Chaser Check is free: it installs the prerequisites and verifies your machine is ready. The full product activates after purchase. Windows 10/11 — macOS is in open beta.
compresseur.py CLI filter, a different path — reattributed, not resealed.) →
verify an entry offline"Strong sense" = you can redo the math without trusting us: frozen corpora, RFC 6962 sealed journal, offline stdlib verifier — replayed from the outside ("valide": true). Full walkthrough.
It proves: 0 facts lost in the sense of the oracle — six fact classes replayed line by line: file paths, line numbers, exit codes, error messages and exceptions, cited symbols, result counters. Every entry carries its sha256 fingerprint, re-checkable in one command.
It does not prove: a failure told in pure prose — no path, no error code, no counter — sits outside the oracle's verdict (a limit our own red team found, published as is). Nothing is destroyed either way: the full original of every output stays recallable through the inline sha256 pointer, always present.
Honest order of magnitude: on the measured sessions, −45 to −57% of tooled input tokens — a few cents per session at that volume; the main savings live in caching and orchestration. (Conditions: Receipts of 2026-08-15 and 2026-08-17, N=54 entries each, local replay at $0, 6-class oracle.)
The token-optimization space got crowded in 2026. Here is where Chaser sits, using each vendor's own published figures as of July 31, 2026 — check theirs, and recompute ours.
These are different tools measuring different things on different workloads — the numbers above are not directly comparable and none of them (ours included) should be read as a promise for your traffic. The honest test is the same for every vendor: measure on your own workload. Ours ships with the measurement journal and the verifier built in.
Your Anthropic bill keeps climbing because a deep model gets called for work a cheaper one could have handled just fine. Multiply that across a team, or across a few months of daily use, and the API line item stops looking like a rounding error.
Then a session crashes mid-task, or you simply open a new one the next morning — and every decision, every fixed bug, every bit of accumulated context is gone. You start over, explaining the same architecture and the same conventions you explained yesterday.
Most tools only chase the API invoice. Chaser also compresses tool outputs before they ever enter the conversation, so work already done is not done again. Your subscription traffic is never modified. Two separate billing surfaces, two opposite levers.
10% of all compressions are randomly held out and checked, never cherry-picked. Every result is sealed in a hash-chained, Merkle-rooted log you can audit yourself — not "our own counters".
Context handoff between Claude Code sessions happens automatically, with no manual re-explaining. Long-term memory is organized in layers, so a new session starts on a distilled summary instead of a wall of raw facts.
Chaser blocks dangerous commands like rm -rf ~ and curl | sh, and catches
hardcoded secrets before anything executes. It runs before the action, not after the damage.
Contextual bandits drive model routing, semantic caches are gated instead of blindly trusted, and savings are backed by anytime-valid statistics. Builds are reproducible and ship with an SBOM.
Your prompts, your API key and your data never leave the machine. The Cockpit dashboard runs on localhost, and uninstalling from Windows is a clean, single-step process.
Every number here follows one rule: no figure is asserted without its confidence interval attached. Where a bound is empirical, we say so. Where two measurements come from different populations, we say that too — and we do not combine them into a single flattering headline.
A public, reproducible benchmark of 30 verifiable tasks (10 trivial, 10 medium, 10 complex), run as two matched arms: the Chaser cascade versus direct Sonnet. Each task is played by both arms, so the delta is measured on the same task rather than on two different populations.
Raw machine-readable data: /bench/index.json · full benchmark page
Check it without trusting us. The engine is closed, so here is
what lets you contradict us:
chaserbench-verification.zip — a
standalone verifier (Python standard library only, no account, no network) that recomputes
our aggregates, medians and anytime-valid bounds with its own implementation instead of copying
ours, plus every run and the frozen corpus. python verifier_bench.py returns CONFORME
or ÉCART; python verifier_bench.py test feeds it six doctored versions of our own
numbers and requires it to catch all six. What it does not prove, plainly: replaying the API
calls is not third-party, and this is our corpus — long, multi-file, tool-heavy agentic sessions
may differ, better or worse. The only number that binds you is the one measured on your own
traffic.
An unmodified fork of AI-Scientist-v2 (SakanaAI) run through an OpenAI-compatible facade,
integrated solely via OPENAI_BASE_URL — zero patches to the fork.
These two figures measure different populations and do not add up. Each claim carries three independent signatures: integrity (Merkle RFC 6962 + Ed25519), execution (attested replay) and validity (adversarial Skeptic review).
All raw data behind these figures is public and independently verifiable. The hypotheses, protocols and reviews cited in the AI-Scientist report are AI-generated — that report states so explicitly.
Our measurement journal is sealed in a Merkle tree (RFC 6962 — the mechanism behind Certificate Transparency logs). You can check a real entry without trusting us and without installing the product:
python verifier_preuve.py preuve_exemple.json — hashes are recomputed
locally, no network call.Since July 31, 2026 the root is Ed25519-signed and the self-contained verifier
(zero dependencies) checks the signature on top of inclusion and consistency. Pinned public key —
compare it against the bundle's: 6a8877cda3e9a7c7cb1cf7ca8e18ef8cbcaf372bcd35d18904edb81e8781d1f8. If the verifier ever prints
"valide": false, publish it.
Nobody has independently verified these proofs yet — be the first. Replay the three steps above (10 minutes, Python 3 is enough), publish what you find under your own name, wherever you like, even if it is unfavorable to us: we will link it here. Independent replication is the one thing these numbers still lack, and it can only come from you.
Anthropic reports 1,000+ customers spending $1M+/year on the API (trade press, 2026) — about $19,200/week each. Extrapolating our proven −58% cost-at-matched-task (paired public benchmark, statistical lower bound > 0, quality preserved) by the share of traffic routed through Chaser:
This is an extrapolation, not a measurement: the −58% is proven on our public benchmark (30 paired tasks, frozen corpus), not yet on a customer of that size. The only proof that counts is a measured pilot on your own traffic — Chaser journals every run and Merkle-seals the measurements, so you verify them yourself. Against a Team licence at 490 €, even the conservative scenario pays for the rollout several hundred times over. Request a measured pilot →
📋 What the measured pilot actually is. 14 days, on your real traffic, without sending us a single byte. Day 0: Chaser seals your baseline consumption into a local Merkle log — it becomes impossible to rewrite after the fact, including by us. For 14 days every orchestration is measured against its "same work without routing" reference. Day 14: a one-page report, signed with Ed25519, carrying the median per orchestration (never the aggregate alone) and the annual projection for your headcount. You verify the signature and the log's integrity yourselves, offline, with the standalone verifier — no trust in us required.
🤝 Savings SLA — the numbered commitment. On the 14-day measured pilot
(baseline sealed on day 0, Merkle log, final report signed with Ed25519 — you verify it yourself,
offline): if the median measured saving per orchestration on your API key is
below 45% of the no-routing reference, the licence is fully refunded. No other tool
can make this commitment, because no other tool lets you audit the measurement: here it is sealed
on your machine and verifiable by you (/preuves/). Scope: orchestrations routed
through Chaser during the pilot and having a comparable reference in their traces
(paid and reference cover the same runs); the indicator is the median per orchestration,
never the aggregate alone.
The rule, without having to trust us: an orchestration is eligible if its trace carries
both the paid cost and the reference cost — no threshold, no setting, no human judgement. A
zero or negative saving still counts: discarding unfavourable cases would lift the
median. The report publishes the number of orchestrations total, eligible and excluded, with
the reason for each exclusion, and those numbers are Merkle-sealed like the rest. Contractual detail in the
terms, §6 bis.
A one-time purchase. No extra subscription: Chaser is a local product you install once, with no recurring cost and no dependency on a third-party service.
Launch pricing. Chaser Check — the diagnostic installer — is free. The full product (routing engine, Shield, memory, Cockpit) unlocks after purchase with a personal, named license key. Runs on Windows 10 and 11; macOS is in open beta.
Everything stays on your machine. Chaser doesn't send anything to a third-party server — the only network calls are the ones you already make to the Anthropic API. Local memory is human-readable and can be inspected or deleted at any time from the Cockpit.
Yes. Chaser is reversible in a single command, which removes the hooks and restores your previous configuration. It also uninstalls from the standard Windows "Apps & features" panel.
Chaser Check installs missing prerequisites (Python, Node.js, Git, Claude Code) and runs a read-only local diagnostic showing what Chaser could lighten — for example how many MCP tool schemas are inflating your system prompt. It doesn't include the routing engine, Shield or memory features; those require a license key.
They're two separate wallets. Your API key is billed per token used — routing, caching and the cascade aim to lower that bill. Chaser never modifies your Claude Code subscription traffic; session recycling and output compression simply avoid redoing work already done.
The routing, cascade and caching logic doesn't depend on today's specific prices — it works as long as a cost or capability gap exists between models. If Anthropic changes its lineup, the routing rules adapt; only the absolute figures in the traces would shift.
The downloaded Chaser-Check.exe must have exactly this SHA-256 fingerprint:
1d1f84d0193737a05bbe2cded0a542a52e677c13b74036ccd863b460558841e4
On Windows, open PowerShell and paste: Get-FileHash "$HOME\Downloads\Chaser-Check.exe" -Algorithm SHA256 — the fingerprint must match. You can also check it on VirusTotal.
Our executables are not code-signed — SmartScreen may warn ("Unknown publisher"); the tarball is the recommended path.
Publisher: Ken Caroly · 100% local — no data sent · reversible in one command