Leverage — Cached Context Amplification
How much your cached context amplifies your fresh input. High leverage means you’re building on a foundation, not starting over.
The formula
Leverage = cache_read / input
Leverage is the ratio of cached context reused to fresh input sent. A leverage of 20 means you’re reusing 20 tokens from cache for every 1 token of fresh input. A leverage of 0.5 means you’re sending 2 tokens of fresh input for every 1 token of cached context — you’re spending more on fresh input than you’re reusing from cache.
The name is deliberate: leverage measures how much your prior investment in context (the cache) amplifies your current investment (fresh input). High leverage is like having a large bankroll working for you — a small fresh deposit moves a lot of cached capital. Low leverage is like starting with an empty account every time.
What leverage means
Leverage captures the amplification effect of prompt caching. When you maintain a stable context across turns, your cached prefix grows. Each new turn sends a small amount of fresh input (the new question or task), but the model processes it against the full cached context (everything from prior turns). Your fresh input is amplified by the cache — a 100-token question is interpreted in the context of 50,000 cached tokens of project history.
This is why leverage matters: it measures whether you’re operating with compounding context (high leverage — the cache does the heavy lifting) or flat context (low leverage — every turn is a fresh start with no accumulated foundation).
High leverage vs low leverage
High leverage — building on prior context
You maintain a stable, growing cached prefix across turns. Each new turn sends minimal fresh input — a targeted question, a small code snippet, a specific instruction — and the model interprets it against the full weight of your accumulated context. You’re building on a foundation. This is the signature of a BUILDER or TRANSMITTER.
Low leverage — re-explaining from scratch
You send large fresh inputs each turn with little cached context to amplify them. You re-explain the project, re-paste the codebase, and re-establish conventions. The model processes your input from scratch with no accumulated understanding. Each turn is an island. This is the signature of an IGNITER — no foundation, no amplification.
Leverage vs cache hit rate
These two metrics measure different aspects of context reuse and are often confused:
- Cache hit rate = cache_read / (cache_read + cache_write) — measures whether your cache writes are paying off (are you reading back what you write?).
- Leverage = cache_read / input — measures whether your cache is amplifying your input (is your cached context large relative to your fresh input?).
You can have a high cache hit rate but low leverage: you read back everything you write to cache, but your cache is small relative to your fresh input (short sessions, frequent topic switches). You can have high leverage but a moderate cache hit rate: your cache is large and amplifies your input, but you also write a lot of new cache that doesn’t get read back. Both metrics matter — they diagnose different problems.
How to increase your leverage
- 1. Maintain long, stable sessions. Leverage grows naturally as a session progresses — the cached prefix accumulates with each turn. The longer your session, the more cache_read builds up. Don’t restart unless you have to. A 50-turn focused session will have far higher leverage than ten 5-turn sessions.
- 2. Send minimal fresh input per turn. Leverage = cache_read / input — shrinking the denominator is as powerful as growing the numerator. Reference prior context instead of re-pasting it. “Add error handling to the function from turn 3” is a 10-token input amplified by 50,000 cached tokens. Re-pasting the function is a 500-token input that barely moves the leverage needle.
- 3. Use structured, stable prefixes. A consistent prefix (project conventions, file layout, system prompt) at the top of your context gets cached on turn one and reused on every subsequent turn. This builds a large cache_read foundation that amplifies all future input.
- 4. Avoid topic switches mid-session. Each topic switch forces new context that doesn’t match the cached prefix. The cache resets, leverage drops to near zero, and you start rebuilding from scratch. Group related work into focused sessions.
- 5. Build incrementally. Ask the model to extend, refactor, or test code it already generated in prior turns. Each incremental request sends small fresh input but leverages the full cached context of the codebase under discussion. Incremental building is the natural mode of high-leverage AI coding.
FAQ
- What is leverage in AI coding?
- Leverage = cache_read / input. It measures how much cached context amplifies your fresh input. A leverage of 20 means you reuse 20 cached tokens for every 1 token of fresh input. High leverage means you’re building on prior context; low leverage means you’re re-explaining from scratch.
- What is a good leverage score?
- Leverage scales with session length — longer sessions accumulate more cache_read. A leverage of 10-20 is typical for a focused mid-session turn. Track the trend: leverage should increase as a session progresses and drop if you restart or switch topics.
- How is leverage different from cache hit rate?
- Cache hit rate measures whether your cache writes pay off (reads vs writes). Leverage measures whether your cache amplifies your input (cache_read vs fresh input). You can have high cache hit rate but low leverage (small cache, large input) or high leverage but moderate hit rate (large cache, some wasted writes). Both diagnose different problems.
- How do I increase my leverage?
- Maintain long, stable sessions (leverage grows as cache accumulates), send minimal fresh input per turn (reference instead of re-pasting), use structured prefixes, avoid topic switches, and build incrementally on prior turns. Session continuity is leverage continuity.
Related metrics: Cache Hit Rate · Yield (Υ) · Compression Ratio · Methodology