Yield (Υ) — Token Cascade Efficiency
The headline SigRank metric. Measures whether your token cascade is compounding signal or burning tokens.
The formula
Υ = (cache_read × output) / input²
Yield combines all four token pillars into a single number. cache_read rewards context reuse — the cached tokens you carry forward from prior turns. output rewards productive generation — the tokens the model gives back. input² penalizes fresh input — and the square means the penalty is non-linear. Double your input and you quarter your yield, all else equal.
The four token pillars are: input (tokens you send), output (tokens the model generates), cache_read (cached tokens reused from prior context), and cache_write (new tokens written to cache). Yield uses three of the four — cache_write is captured indirectly through future cache_read.
What it measures
Yield measures the architecture of your token cascade — whether signal is compounding or tokens are being burned. An operator who sends 10,000 fresh input tokens, reuses 50,000 from cache, and gets back 8,000 output tokens is running an efficient cascade. An operator who sends 50,000 fresh tokens, reuses nothing, and gets back 2,000 output tokens is burning tokens.
Volume is noise; yield is signal. Raw token counts tell you how much you spent. Yield tells you how much you got for what you spent — and whether your context strategy is working.
Why it’s the headline metric
Yield is the single number that captures the full cascade. Other metrics isolate one dimension — compression ratio measures output per input, cache hit rate measures context reuse, leverage measures cached amplification. Yield blends all of them. An operator can have a high compression ratio but low yield (if they never reuse cache). An operator can have a high cache hit rate but low yield (if they produce little output). Yield is the only metric that rewards getting all three dimensions right simultaneously.
The input² denominator is the key design choice. It makes yield sensitive to input economy in a way that linear ratios are not. This reflects a real asymmetry: fresh input tokens are the most expensive part of the cascade (they cost full price and must be processed from scratch), so the metric penalizes waste there disproportionately.
What high and low yield means
High yield
Your cascade is compounding. You reuse cached context efficiently, send minimal fresh input, and the model produces substantial output. You’re building on prior turns rather than re-explaining from scratch. This is the signature of a TRANSMITTER — an operator whose signal accumulates across a session.
Low yield
Your cascade is burning tokens. You send large fresh inputs, reuse little or no cache, and get back relatively little output. Each turn starts from scratch. This is the signature of an IGNITER — an operator who hasn’t yet built the context discipline that makes signal compound.
Example calculations
Example A — Efficient cascade
input = 2,000 · cache_read = 40,000 · output = 6,000
Υ = (40,000 × 6,000) / 2,000² = 240,000,000 / 4,000,000 = 60
High cache reuse, moderate output, low fresh input. Signal is compounding.
Example B — Token burn
input = 30,000 · cache_read = 0 · output = 3,000
Υ = (0 × 3,000) / 30,000² = 0 / 900,000,000 = 0
No cache reuse kills yield — the cache_read term zeroes the numerator regardless of output. Every turn starts from scratch.
Example C — Input-heavy
input = 20,000 · cache_read = 30,000 · output = 10,000
Υ = (30,000 × 10,000) / 20,000² = 300,000,000 / 400,000,000 = 0.75
Good cache reuse and output, but the large fresh input crushes yield via the squared denominator. Trimming input from 20k to 5k would raise yield to 12 — a 16× improvement from a 4× input reduction.
Class tier mapping
Yield ranges map to SigRank class tiers, from lowest to highest:
- IGNITER — Low yield. Just starting out; context discipline not yet developed. Every turn is a fresh start.
- SEEKER — Improving yield. Beginning to reuse cache and trim input, but output is still modest.
- BUILDER — Efficient cascade. Consistent cache reuse, economical input, substantial output. Signal is compounding.
- TRANSMITTER — Top decile. The cascade is a flywheel: minimal fresh input, heavy cache reuse, high output. Signal compounds across the entire session.
Exact yield thresholds are calibrated from the live leaderboard and shift as the operator population grows. The tier you land in reflects your cascade architecture relative to the current field.
How to improve your yield
- 1. Maximize cache reuse. Keep your context stable across turns. Don’t restart sessions unnecessarily. Prompt caching rewards continuity — the longer your cached prefix, the more cache_read accumulates and the higher your numerator climbs.
- 2. Trim fresh input aggressively. The input² denominator means every token you cut from fresh input has a squared effect on yield. Remove redundant context, avoid re-pasting code that’s already in cache, and use file references instead of inline blocks when possible.
- 3. Ask for substantive output. Request deliverables — code, analysis, explanations — rather than yes/no confirmations. More output tokens means a higher numerator. A turn that produces 5,000 output tokens contributes far more to yield than one that produces 50.
- 4. Use structured prefixes. Stable, structured context at the top of your prompt (project conventions, file layout, coding standards) gets cached and reused. Chaotic, re-ordered context breaks the cache and forces fresh processing every turn.
- 5. Build on prior turns. Reference earlier output instead of re-explaining. “Refactor the function you just wrote” leverages cache; “here is a function, refactor it” burns fresh input. Conversation continuity is yield continuity.
FAQ
- What is the yield metric in AI coding?
- Yield (Υ) = (cache_read × output) / input² is the headline SigRank metric. It measures token cascade efficiency — how well an AI operator converts fresh input into output, amplified by cached context. High yield means signal is compounding; low yield means tokens are burned.
- Why is yield the headline SigRank metric?
- Yield captures all four token pillars in a single number. It rewards cache reuse, output production, and input economy simultaneously. Volume alone is noise — yield measures the architecture of the cascade, not raw spend.
- What is a good yield score?
- Yield ranges map to class tiers: IGNITER (low), SEEKER (improving), BUILDER (efficient), and TRANSMITTER (top decile). Thresholds are calibrated from the live leaderboard. The gap between median and TRANSMITTER is where most improvement lives.
- How do I improve my yield?
- Three levers: increase cache_read (stable context, structured prefixes), increase output (ask for substantive deliverables), and decrease input (trim redundant context). The input² term means cutting input has a squared effect — small reductions produce large yield gains.
- Does yield depend on the AI model I use?
- No. SigRank scores the operator, not the model. Yield is computed from four token counts that every platform reports. The same operator on Claude, ChatGPT, Gemini, or Cursor produces comparable yield scores because the metric measures how you drive the AI, not which AI you drive.
Related metrics: Compression Ratio · Cache Hit Rate · Leverage · Methodology