We measured 6,104 real coding-agent sessions from 310 developers using exact per-request API accounting: the token counts the vendors themselves report, added up so they match the full bill. Not a survey and not a simulation of synthetic tasks, but real work at the prices it was actually charged.
MemBridge keeps the same ledger for your own repos: it reads the session logs your agents already write, and the app shows the tokens it avoided, per project. Nothing leaves your machine.
Re-orientation is your agent re-reading, re-searching, and re-deriving context in a codebase it has already worked in. Across the 174 developers with five or more sessions, the median share of billed tokens spent this way is 31.2%, and nine in ten developers sit above 16%. At the corpus level, re-orientation accounts for $13,776 of the $56,666 measured, or 24.3% of everything spent.
We measured ourselves first. Our own repositories sit below the population's 10th percentile (more efficient than roughly nine in ten developers we measured), and we still burn 13.5%. We built MemBridge because even the efficient end of this chart is paying a permanent tax.
Median across the 96 repositories with enough session history to measure, ranging as high as 81%. Your agent's breakthroughs from this morning are invisible to the session you open after lunch, and everything your teammate's agent figured out is gone. The waste is worst exactly where teams work together.
Orientation share stays stubbornly high with repo experience: a developer's tenth session in a repo re-orients as much as their first, and even past twenty sessions the median still spends more than a fifth of billed tokens re-orienting. Agents do not learn their way around your codebase on their own.
Median re-orientation share of billed tokens, grouped by how many sessions that developer had already worked in that repo. These buckets are medians over individual sessions, while the 31.2% headline is a median over developers with each developer's sessions pooled first, which is why the two sets of figures sit on different scales.
The model counts only re-reading that could be shown as redundant. Every token is priced at what it actually cost, and the memory MemBridge injects is charged against the total. The result is a range rather than one number, because one input has to be estimated: what it costs to carry the injected memory. That estimate is shown rather than folded into the result.
| Tier | On this corpus | Of total spend |
|---|---|---|
| Ceiling: all re-orientation eliminated (not achievable, since first visits are real work) | $13,776 | 24.3% |
| Gross: all measurably redundant orientation eliminated | $4,692 | 8.3% |
| Net, if carrying the memory costs 10% of what it saves estimated input | $4,223 | 7.5% |
| Net, if it costs 20% estimated input | $3,753 | 6.6% |
| Net, if it costs 30% estimated input | $3,284 | 5.8% |
The range was recalculated on a much larger corpus. It was first worked out on 20 developers. Run again on a corpus fourteen times larger, it came out the same, even though the share of tokens going to orientation doubled between the two. The extra orientation was first-time reading, which memory cannot save, and the model separates first-time reading from repeat reading.
For a developer using agents heavily, that band is $1,900–$5,200 a year in tokens alone. For a 50-person agent-first engineering org paying three or four vendors at once, it's a real line item. Apply the measured 24.3% rate to the roughly $10B enterprise coding-agent market and the industry is spending on the order of $2.4B a year re-deriving what its agents already knewextrapolation. That is the measured rate multiplied by a published market size, and nothing more.
And the dollars are the smaller half. The median session spends its first several turns re-orienting before it touches a file: minutes of a developer watching a spinner, several times a day. MemBridge collapses that to one or two. Tokens are what the ledger counts; time is what you feel by Wednesday.
Every API request reports its exact context size: input, cache-creation, and cache-read tokens. Compare one request with the next, subtract what the model itself wrote, and what remains is what the agent's own tool results added. Adding those up gives the total number of tokens billed. Each block of context costs its size times the number of requests it stays loaded for, at published rates, with the discount cached tokens get. The totals match the full bill by design, and any session whose numbers do not add up is dropped from the study and counted, never estimated.
Only clear read-only inspection is counted as orientation. Anything that could be read either way is left out, so every waste figure here is a lower bound.
Real sessions, none of them collected by the product: the SWE-chat research corpus of consenting open-source developers (Stanford SALT, used under ODC-BY; Baumann et al., 2026, arXiv:2604.20779), public Entire checkpoint data from open-source repositories, and our own transcripts. All figures published here are aggregates under anonymous labels.
MemBridge reads the session files your agents already keep on disk, and keeps a running ledger of the tokens it avoided on repeat reads, per project, on your own machine. Then it makes that number go down: one shared memory across the AI coding tools your team already uses.