Canonical metrics and framework definitions.

Canonical token telemetry.

All Upsilon metrics are computed from four token counts collected per AI interaction. No prompt text. No output text. No conversation content. The privacy model is structural, not policy-based: the content was never collected, so it cannot leak.

Provider coverage: ChatGPT, Claude, Codex, Copilot, Cursor, MCP-connected tools. Telemetry is labeled MEASURED — it is observed directly, not derived. Derived metrics carry their own evidence labels. Client-safe implementations use safeI = max(I, 1) to avoid division-by-zero.

From input to Yield: the token cascade.

A cascade is the token-flow decomposition from fresh input through generated output, cache commitment, and cache reuse. Three cascade stages telescope into Yield — the signature Upsilon metric.

Transmission × Commitment × Reuse = (O/I) × (W/O) × (R/W) = (R × O) / I² = Yield (Υ)

The cascade telescopes: the intermediate terms cancel, and the product reduces to (cache_read × output) / input². This is why Yield is the signature metric — it captures the entire cascade in a single number.

The eight.

Each metric captures a different dimension of AI operator token-flow behavior. Together they form a complete picture of how a human operates an AI system, without ever reading a single prompt or output.

Yield (Υ)

Yield = (R × O) / max(I, 1)²

Combined reuse and output relationship — how much reusable signal the operator creates from each unit of input. The signature Upsilon metric. Sensitive to small input denominators; plausibility checks matter. Client-safe implementation uses safeI = max(I, 1).

Does NOT establish: Correctness, novelty, user satisfaction, economic value, code quality, safety, talent, effort, or intelligence. Yield measures a token-flow relationship, not a productivity or quality verdict.

How MO§ES™ uses it: Low Yield flags operators who either burn input without producing proportional output, or fail to reuse cached context. The recommended action depends on which cascade stage is weak — context structuring coaching for low Transmission, context caching workshops for low Reuse.

Signal-to-Noise Ratio (SNR)

SNR = O / (I + O)

Output share of fresh input plus output. Measures the signal quality of the ongoing token exchange — how much of the fresh flow is productive output versus input. Returns 0 when the denominator is not positive.

Does NOT establish: Output quality. SNR measures the ratio, not whether the output is correct or useful.

How MO§ES™ uses it: Low SNR flags operators whose output is drowned by fresh input. The recommended action is prompt precision coaching — helping the operator reduce noise in their input strategy.

Velocity

Velocity = O / max(I, 1)

Output per fresh input. Measures how productively the operator converts input to output. Ignores cache creation cost — a high velocity achieved by never building context is not sustainable.

Does NOT establish: Ignores cache creation cost. Velocity alone doesn't tell you whether the operator is building reusable context or just burning input.

How MO§ES™ uses it: Velocity is the Transmission stage of the cascade. Low Velocity with high input flags operators who over-prompt without producing proportional output.

Leverage

Leverage = R / max(I, 1)

Cache reuse per fresh input. Measures how much the operator leverages previously built context rather than supplying fresh input. High leverage means the operator reuses cached context efficiently. Low leverage means more fresh input per interaction.

Does NOT establish: Causal leverage or business value. Leverage measures a token-flow ratio, not whether the reused context actually helped.

How MO§ES™ uses it: Low leverage flags operators who start from scratch every session. The recommended action is a context caching workshop — teaching the operator to reuse and build on prior context.

10xDEV

10xDEV = log₁₀(Leverage) = log₁₀(R / I)

Logarithmic cascade summary. The product form log₁₀((O/I) × (W/O) × (R/W)) algebraically simplifies to log₁₀(R/I) = log₁₀(Leverage) when I > 0. Unavailable for incomplete cascades — only valid when all four pillars are positive.

How MO§ES™ uses it: 10xDEV compresses the cascade into a single logarithmic score. A 10xDEV of 1 means Leverage of 10 (10× more cache reuse than fresh input). A 10xDEV of 2 means Leverage of 100. The log scale makes cohort comparison tractable.

Scale V

V = log₁₀(I + O + W + R)

Log token volume. Measures the scale of the operator's AI usage — total tokens flowing through the system. Does not establish activity quality. A high V with low Yield is the divergence signature: lots of activity, poor efficiency.

How MO§ES™ uses it: V is the usage dimension for divergence analysis. Combined with evaluation rank, it identifies operators whose usage volume doesn't match their performance.

Construction

Construction = W / R

How much new context the operator builds per read. Used in archetype classification. Greater than 1 means the operator builds more new context than they reuse. Less than 1 means they reuse more than they build. Neither direction is inherently better — construction describes the operator's context architecture pattern, not a quality verdict.

How MO§ES™ uses it: Extreme construction values flag operators whose context strategy may be imbalanced. The recommended action is a context architecture review — not a verdict, a diagnostic.

Efficiency

Efficiency = (R + W + O) / max(I, 1) / 4

Display diagnostic. A policy choice, not a scientific universal. Combines cache read, cache write, and output relative to input, normalized by 4. Used for dashboard display and quick scanning, not for benchmarking or decisions.

Does NOT establish: Scientific universal. Efficiency is a display convenience, not a canonical metric. Use Yield, Leverage, and SNR for actual evaluation.

MO§ES™ supporting concepts.

Beyond the eight Upsilon metrics, the MO§ES™ governance framework defines diagnostic concepts for identifying performance patterns, reference populations for benchmarking, experimental methods for testing interventions, and governance labels that ensure measurement is used developmentally, not punitively.

Divergence

Divergence = Usage Rank − Evaluation Rank

Usage rank is by Scale V (log token volume). Evaluation rank is by Yield or 10xDEV. Positive divergence means high usage, low performance — the operator is active but not effective. Negative divergence means low usage, high performance — the operator is efficient. Divergence is a diagnostic signal labeled HYPOTHESIS, not a verdict. It is task-dependent and should trigger investigation, not action.

How MO§ES™ uses it: High positive divergence flags operators who may need coaching despite appearing "active" on usage dashboards. High negative divergence identifies efficient operators whose practices may be worth sharing.

Benchmark

A performative benchmark in MO§ES™ is defined as TASK × MODEL × OPERATOR × CONTEXT. The framework defines 13 benchmark classes:

1. Standard Metrics — the eight Upsilon metrics as baseline
2. Internal Cohort — comparison within the same organization
3. External Field — comparison against the public reference field (SigRank)
4. Bespoke Workflow — company-specific workflow evaluation
5. Longitudinal — same operator over time
6. Intervention — pre/post comparison around a targeted change
7. Role-Specific — comparison within a job function
8. Model-Specific — comparison across operators using the same model
9. Task-Specific — comparison on the same task type
10. Cross-Model — same operator across different models
11. Team-Level — aggregate team performance
12. Percentile Band — positioning within a reference distribution
13. Divergence — usage vs performance gap analysis

Results are reported as percentile bands: 50th, 75th, 90th, 95th, 99th, 99.9th. The selection algorithm: define the question → identify scope → select classes → compute → report with bands.

Intervention

A targeted change to workflow, tooling, or training, measured with pre/post comparison. The target metric and follow-up window are declared before the intervention deploys. The framework defines 12 tested interventions:

Governance: Intervention outcomes are labeled ASSOCIATION, never CAUSATION. The pre/post design controls for some confounds but not all. A controlled experiment with a comparison group is required before claiming causation.

Canonical Telemetry

The four content-free token primitives (I, O, R, W) defined above. What is collected: four token counts per interaction. What is not collected: prompt text, output text, conversation content, PII, code, transcripts. Telemetry is labeled MEASURED — directly observed, not derived. Provider coverage: ChatGPT, Claude, Codex, Copilot, Cursor, MCP-connected tools.

Governance

The governance framework defines evidence labels and decision-use labels that constrain how measurement results can be used.

Evidence Labels

• PROVEN — established, replicated, peer-reviewed
• MEASURED — directly observed from telemetry
• OBSERVED — recorded but not directly measured
• DERIVED — computed from measured values
• HYPOTHESIS — proposed explanation, not yet tested
• PILOT — early-stage, limited scope, not generalizable

Decision-Use Labels

• DEVELOPMENTAL — for coaching, training, improvement
• ASSOCIATION — correlated, not causally established
• VALIDATION REQUIRED — cannot be used for decisions without further validation

Core Constraints

• No punitive use. No automatic adverse employment actions.
• No employee ranking by name in reports shared with management.
• No surveillance by default. No prompt or output content collection.
• No collapsing evidence levels (e.g., reporting HYPOTHESIS as PROVEN).
• No retroactive metric selection (declaring a metric significant only after seeing results).

Provenance is tracked for every result: source system, canon backing, authority approval reference. Privacy is structural — content was never collected, so it cannot leak.

Go deeper

• Methodology — the full eval framework
• AI Evaluation — the four-layer landscape
• Confirmation Hacking — how evaluation can go wrong
• Product — what MO§ES™ benchmarks
• How to Evaluate AI Operators