What raising your Context SNR buys you
Same task, same repo, same model. The only change: the window carries memory instead of history.
We measured real coding sessions at about 1.5% Context SNR — that is the share of the context window actually serving the commit. The teardown is here.
This piece answers the next question: if you raise it, what do you actually get?
Three things you feel immediately — time, cost, completion. And one you only notice after a few weeks: compounding.
Speed: the first edit lands before you would have finished re-explaining
A cold agent spends its opening minutes reconstructing the world: git log, rg, re-reading files it has read a dozen times, asking you to explain the project again. A warm agent skips to the part where it works.
| Metric | Low SNR (cold) | High SNR (warm) |
|---|---|---|
| Re-grounding latency | 90s+ | under 30s |
| Time per turn | 2.35 min | 0.94 min |
You are used to watching the agent think for four or five minutes before anything useful happens. With a warm start, useful work begins in about thirty seconds.
It is fast in a way that feels wrong the first time. Then it feels like the only acceptable way to start.
Cost: the same signal, without the noise bill
| Metric | Low SNR (cold) | High SNR (warm) |
|---|---|---|
| Input tokens (same task) | 1.51M | 0.32M |
| Tool calls per turn | 16.05 | 4.13 |
| Repo reads per turn | 9.51 | 1.22 |
Scale it up. Across the 1.70 billion tokens we audited, an average SNR of 50% would have delivered the same effective signal for roughly 51M tokens — and, scaling session time proportionally, saved about 44 hours. That is five and a half working days, per quarter, per heavy user.
The point is not a cheaper plan. It is that simple things finish in the time they deserve — and complex things stay affordable enough to actually finish.
Reliability: constraints stop vanishing
The most expensive failure in our teardown was not slowness. It was T66: the agent re-read the critical constraint — v21 assets must stay private — and then proposed a plan that violated it, because the signal was buried under 200K tokens of its own debugging scenery. One wrong plan, one correction round, three turns, 622.5K tokens.
With a high-SNR start, that failure class shrinks structurally:
- Constraints arrive pinned in the launch pack — not on page 200 of the transcript.
- Failed approaches come in as autopsies, so nobody walks the dead road twice.
- Compaction stops deciding which of your decisions survive, because you exit before it fires.
Complex tasks rarely die because the model is weak. They die because the one constraint that mattered sank below the noise.
Compounding: every task makes the next one cheaper
Here is the effect that does not show up in a single A/B run. Every finished task deposits memory — decisions, constraints, autopsies, repo understanding. The next warm-up starts richer than the last one. Cold starts cost the same forever; warm starts get cheaper every week.
Context you cannot reuse is rent. Context you can reuse is a down payment.
The dividing line in AI-assisted work is not whose model is stronger. It is whose context compounds.
Honest numbers
- These are one team’s same-task A/B runs — dogfooding, not a public benchmark.
- Your ratios will differ with repo size, task type, and session hygiene.
- The direction is the point: every number moves the same way, every time we run it.
Do this today
- Measure first: generate your Context SNR report and see where you actually stand.
- Then raise it: connect Echo MCP, warm up your next task, and exit sessions before compaction.
Low SNR is a tax. High SNR is compound interest.
You pay the tax every turn, in waiting, in tokens, in constraints that vanish. Or you flip the ledger — and every session you run makes the next one start stronger.