Reducing the token cost of long-running agents.

The question

An agent that works all day re-sends nearly identical context hundreds of times, and pays full price for it on every call. How far can the marginal token cost of an agent step be driven down, through prompt cache discipline, aggressive context compression, and knowledge precompiled into compact executable form, before decision quality measurably degrades?

Why it matters

Token spend is the difference between an agent that's cheaper than the work it replaces and one that isn't. Most deployments fail on unit economics, not capability. If a step that costs a full context read can be made to cost a fraction of it, entire categories of always-on automation stop being luxuries and start being obvious.

What we're doing

We're profiling where real agent workloads actually spend tokens, then working through six levers in priority order: prompt-cache discipline so context prefixes keep hitting cache as an agent moves through a codebase; context compression that turns raw history and re-read files into state the model can trust instead of raw transcripts; knowledge precompiled once into skills files so it isn't re-explained on every call; an external index of the codebase so an agent stops re-searching files it already read; section-level reading and editing so an agent pulls and patches only the span that changed instead of a whole file; and reasoning-token overhead, since more thinking doesn't reliably mean a better decision. Cache and compression can work against each other, since rewriting a prompt to compress it destroys the cached prefix, so part of the work is mapping where each actually nets a win. Every technique is scored the same way: tokens saved per step against task success over repeated runs, with silent quality degradation and other failure modes documented as carefully as the wins.