How does SigRank measure AI operator efficiency?

SigRank uses the Yield metric (Υ = cache_read × output / input²) to measure token cascade efficiency — how well an operator converts fresh input into output, amplified by cached context reuse.

What metrics does SigRank track?

SigRank tracks four token pillars (input, output, cacheCreate, cacheRead) and derives Yield (Υ), Leverage (Cr/I), Velocity (O/I), and 10xDEV (log₁₀(leverage)). Operators are classified into tiers from Burner to 10xer.

Why is yield better than raw token count?

Raw token count measures volume, not efficiency. An operator who sends a million tokens with no cache reuse scores low on yield. Yield measures the architecture of the cascade — how well you compound signal, not how much you burn.

◈ Blog · Operator Metrics

How SigRank Measures Operator Efficiency

The yield metric (Υ = cache_read × output / input²) measures how well AI operators convert tokens into useful output. Here's how it works and why it matters.

By SigRankPublished July 7, 20268 min read

When you use an AI coding tool, you send tokens in and the model sends tokens back. That exchange — the token cascade — is the atomic unit of AI-assisted work. But “I used a lot of tokens” tells you nothing about whether you used them well. A developer who burns a million tokens re-explaining context the model already has is not efficient — they're just spending.

SigRank measures operator efficiency with a single derived metric called yield (Υ). It captures, in one number, how well an operator converts fresh input into useful output — amplified by the reuse of cached context. This post breaks down exactly what yield measures, where the numbers come from, and why it beats raw token count as a measure of skill.

The four token pillars

Every SigRank measurement starts with four integers read from your local AI tool logs — no prompt content, just counts. These are the pillars every derived metric is built from:

Input — fresh tokens you send to the model. This is the expensive resource: every input token costs compute and adds noise.
Output — tokens the model generates back. This is the useful product: code, answers, explanations.
Cache-create — new tokens written to the prompt cache for future reuse. An investment in later efficiency.
Cache-read — cached tokens reused from prior context. The cheapest, highest-leverage tokens in the cascade: work the model already has and doesn't need to be told again.

From these four integers, SigRank derives the metrics that actually describe how well you drive the cascade.

The yield formula

Yield is the headline efficiency metric. The formula is deliberately simple:

Υ = (cache_read × output) / input²

Three things happen in this formula, and each is intentional:

Cache-read is multiplied

Reusing cached context is the cheapest way to get work out of the model. Multiplying by cache_read rewards operators who build on prior turns instead of starting from scratch every time.

Output is multiplied

Producing more useful output per turn is the point. Multiplying by output rewards operators who extract real work from the model, not just conversation.

Input is squared in the denominator

Fresh input is the expensive resource. Squaring it in the denominator means doubling your input quarters your yield — all else equal. This penalizes operators who flood the model with fresh context instead of reusing cached results.

The result is a single number that rises when you reuse context and produce output, and falls when you burn fresh input. High yield means your cascade is compounding signal. Low yield means tokens are being burned.

The derived metrics

Yield is the headline, but SigRank derives three companion metrics that each isolate one dimension of the cascade. Together they tell you where your efficiency is won or lost:

Leverage = cache_read / input. How much cached context amplifies each input token. A leverage of 10 means every input token is backed by ten cached tokens. This is the metric that replaces “hours” in the AI era: it measures how much mileage you get from each token you spend.

Velocity = output / input. How much output you get per unit of input. High velocity means your prompts are tight and the model is producing; low velocity means you're spending a lot to get a little.

10xDEV = log₁₀(leverage). A logarithmic scale that turns leverage into a readable tier number. A 10xDEV of 1 means leverage 10; a 10xDEV of 2 means leverage 100. It's the headline number for classifying operators.

Operator tiers — from Burner to 10xer

SigRank doesn't just give you a number — it classifies you into a tier that describes the shape of your cascade. The tiers run from Burner (low efficiency, high burn) to 10xer (the AI power user archetype: high cache reuse, high output per input, disciplined token architecture):

Burner — low yield, high input, little cache reuse. Tokens are being burned, not compounded.
Builder — moderate yield, building cache depth. The middle of the distribution; most operators start here.
10xer — high yield, high leverage, high velocity. The operator whose cascade compounds: every input token is amplified by cached context and converted into output.

You can see your tier instantly at /score, and compare it against the field on the leaderboard.

Why yield beats raw token count

Raw token count is the metric people reach for first, and it's the one that misleads most. An operator who sends a million tokens with no cache reuse and little output looks “productive” by volume — but their cascade is burning, not building. Yield exposes the difference.

Yield measures the architecture of your cascade, not the volume. It rewards the three behaviors that actually define a skilled AI operator: reusing cached context, producing output, and keeping fresh input lean. Token count rewards none of these — it just rewards spending. That's why yield is the headline metric and token count is, at best, a diagnostic input.

The full methodology — including the scoring ruleset, tier boundaries, and how snapshots are verified — is on the methodology page.

See your yield

The fastest way to measure your own operator efficiency is one command:

npx sigrank

Already have token stats? Score your yield instantly →

FAQ

How does SigRank measure AI operator efficiency?: SigRank uses the Yield metric (Υ = cache_read × output / input²) to measure token cascade efficiency — how well an operator converts fresh input into output, amplified by cached context reuse.
What metrics does SigRank track?: SigRank tracks four token pillars (input, output, cacheCreate, cacheRead) and derives Yield (Υ), Leverage (Cr/I), Velocity (O/I), and 10xDEV (log₁₀(leverage)). Operators are classified into tiers from Burner to 10xer.
Why is yield better than raw token count?: Raw token count measures volume, not efficiency. An operator who sends a million tokens with no cache reuse scores low on yield. Yield measures the architecture of the cascade — how well you compound signal, not how much you burn.