Early access — cascade metrics are real (derived from canonical token telemetry); the operator field is a curated seed. Learn more about the data
◈ Troubleshooting Guide

Cache Write Convergence

ChatGPT and Codex report cache_write as zero. Here is why, how to split the signal, and how to validate which operating ratio fits.

The problem

ChatGPT and Codex bundle cache_write into input and report cache_write as near-zero. When SigRank seeds a ChatGPT operator, their cache_write shows as 0, which flags them as non-compounding, nulls their yield, and sorts them to the bottom of the board.

To fix this, we use reference operating ratios to split the combined input into true fresh input and cache_write. Three ratios are used:

  AA avg:      3.5 : 1 : 0.5    (cache_read : input : output)
  HCM:        20   : 1 : 0.1
  Codex PU:  243   : 1 : 1.03

The question: which ratio is correct for a given operator? And can we use the operator’s real cache_read to validate the choice?

The method

For a ChatGPT operator, we know three real numbers:

  • Output (real, reported correctly)
  • Cache read (real, reported correctly)
  • Combined input (real, but includes hidden cache_write)

We use the velocity term (output/input) from each reference ratio to solve for input:

  input = output / velocity
  cache_write = combined_input - input

Then we compute the operator’s actual leverage and yield:

  leverage = cache_read / input
  velocity = output / input
  yield = leverage x velocity

Case study: kr-yeon

  Output:           23,655,246    (23.7M)
  Cache read:    5,845,750,656    (5.85B)
  Combined input:   280,931,419   (280.9M)

Results across three ratios:

                      ChatGPT       AA avg         HCM       Codex PU
                     (broken)    3.5:1:0.5     20:1:0.1   243:1:1.03
  ─────────────────  ────────────  ────────────  ────────────  ────────────
  Input                280,931,419    47,310,492  236,552,460    22,966,258
  Output                23,655,246    23,655,246   23,655,246    23,655,246
  Cache write                   0   233,620,927   44,378,959   257,965,161
  Cache read          5,845,750,656 5,845,750,656 5,845,750,656 5,845,750,656
  ─────────────────  ────────────  ────────────  ────────────  ────────────
  Velocity                   0.08          0.50         0.10         1.03
  Leverage                 20.8:1       123.6:1       24.7:1      254.5:1
  Yield                     NULL        61.78         2.47       262.17
  Class                    ARCH       SEEKER      IGNITER        POWER
  Rank                    #1514        #242         #706         #137

The red herring: cache write

Real operator data (1,495 operators with all 4 real pillars) shows that cache_write is roughly constant across profiles:

  HCM operators (leverage 15-25x, n=276):
    avg cache_write:  313.4M
    avg input:      1,501.5M

  PU operators (leverage 200-300x, n=50):
    avg cache_write:  269.3M
    avg input:         37.2M

  Difference in cache_write:  1.2x
  Difference in input:       40.4x

Now look at what each ratio produces for kr-yeon:

  AA avg:    233.6M cache_write    (within real range)
  HCM:        44.4M cache_write    (6x below real range)
  Codex PU:  258.0M cache_write    (within real range)

HCM produces a cache_write number that does not exist in real data. No cohort of operators at any leverage level produces 44M cache_write. The HCM ratio is broken for this operator.

Why HCM breaks

HCM’s velocity is 0.1, meaning input = output / 0.1 = 236.6M. That consumes 84% of the combined input (280.9M), leaving only 44.4M for cache_write.

Real HCM operators have 1,501.5M input. Their combined input is large enough that even at 0.1 velocity, there’s room for 313M of cache_write. kr-yeon’s combined input is only 280.9M. HCM’s velocity assumption eats it alive.

The HCM ratio works on real HCM operators because they have massive input. It fails on ChatGPT operators whose combined input is small relative to their output, because the low velocity forces input to consume nearly all the combined input, starving cache_write.

Why AA avg and Codex PU hold

  AA avg (velocity 0.5):
    input = 23.7M / 0.5 = 47.3M    (17% of combined)
    cache_write = 233.6M           (matches real data)

  Codex PU (velocity 1.03):
    input = 23.7M / 1.03 = 23.0M   (8% of combined)
    cache_write = 258.0M           (matches real data)

Both produce cache_write in the 233-258M range, which is consistent with what real operators at those leverage levels actually create.

The broader pattern

Cache write is roughly constant across operator profiles (270-313M regardless of leverage level). This suggests cache_write is a function of total context built, not of input volume or output volume. You build a context library, and that library has a size.

Input is the variable that separates profiles. HCM operators use 1,501.5M input. PU operators use 37.2M input. The difference is 40x. PU operators achieve the same or better results with 40x less input because they compound more efficiently.

Implications

1. Cache write is the validation signal

When re-parsing a ChatGPT operator, check the cache_write produced by each ratio against real operator data. If it’s far outside the 270-313M range, the ratio does not fit.

2. HCM breaks on low-combined-input operators

HCM’s velocity of 0.1 forces input to consume most of the combined input, producing an impossibly low cache_write. This ratio should not be used for ChatGPT operators with small combined input relative to output.

3. AA avg and Codex PU are both viable

They produce similar cache_write numbers. The choice between them is a velocity question, not a cache question.

4. The operating ratio is cache_read : input : output

Not cache_write. cache_write is the derived number we solve for. cache_read is the real number that validates the solution.

FAQ

Why does ChatGPT report cache_write as zero?
ChatGPT and Codex bundle cache_creation_input_tokens into the input field. The API returns the combined total as input_tokens and reports cache_creation_input_tokens as zero. The cache write happened, it is just not separated out in the summary.
What is the cache_write red herring?
Cache_write is the derived number when re-parsing ChatGPT operators. It is what we solve for using operating ratios. When the derived cache_write matches what real operators produce (270-313M), the ratio fits. When it does not, the ratio is broken. HCM produces 44M cache_write for kr-yeon, 6x below the real range, proving it does not fit.
Which operating ratio should I use for ChatGPT operators?
For most ChatGPT operators, AA avg (3.5:1:0.5) and Codex PU (243:1:1.03) both produce cache_write in the real range. HCM (20:1:0.1) fails on operators with small combined input relative to output because its low velocity forces input to consume most of the combined input, starving cache_write.
What is the operating ratio?
The operating ratio is cache_read : input : output (with input normalized to 1). It is NOT cache_write. cache_write is the derived number we solve for. cache_read is the real number that validates the solution.

Methodology notes

  • Real operator data: 1,495 operators with all 4 pillars (input, output, cache_write, cache_read) reported. These are primarily Claude/Anthropic users whose telemetry reports cache_write correctly.
  • HCM-like: cache_read/input between 15 and 25 (n=276)
  • PU-like: cache_read/input between 200 and 300 (n=50)
  • AA-like: cache_read/input between 2 and 5 (n=110)
  • kr-yeon: ChatGPT user, cache_write reported as 0, combined input = 280.9M
← All guides← Volume Isn’t Yield: The Shape of AI Operators