Compute Finance Oracle

Raw JSON per-inference breakdown — token counts, tool usage, effective/nominal cost, cache hit ratio, duration per inference. One row per assistant reply. `inferences[].effective_usd` is `null` when the oracle has not published cache pricing for the model; `nominal_usd` stays populated as an upper-bound. Source: local Claude Code transcript + Oracle API. For pre-formatted output use render_consumption_report. Omit session_id for the most recent session.

Raw JSON session analysis — token totals, effective/nominal cost with cache breakdown, counterfactual across every model in the current SCU index, profile classification. `current_model_cost` is on the base (provider list) basis, stated in `current_model_cost_basis`; `counterfactual_nominal` rows carry `base_usd_cost` and `billed_usd_cost`, so the session and the counterfactual are directly comparable on base. Counterfactual rows quote each model's base rate and never a long-context rung: a rung is picked per request, and a session's summed input is not one giant request, so pricing the total on a higher rung would overcharge — expect these rows to sit below compute_compare for a model that gets pricier past a context length. `usage.prompts` counts user messages, `usage.inferences` counts assistant replies, `usage.tool_calls` counts tool_use blocks. `current_model_cost.effective_usd` is `null` when the oracle has not published cache pricing for the model; `nominal_usd` stays populated as an upper-bound. Source: local Claude Code transcript + Oracle API. For pre-formatted output use render_session_report. Omit session_id for the most recent session.

Rank every model in the current SCU index by nominal cost for a workload. Source: Oracle API (/v1/oracle/catalog). Cache reads and cache writes belong inside input_tokens and are charged at the full input rate here; no cache discount is applied. Each row carries `base_usd_cost` (provider list price), `routing_fee_usd` and `billed_usd_cost` (what compute.finance charges); ranking is by base_usd_cost, and since the routing fee is one global rate the order is identical on either basis. Every row is priced at the rung input_tokens selects on that model's own ladder, returned whole as `applied_context_tier`, so a model that gets pricier past a threshold ranks where it truly lands at this size; for every rung read `context_tiers` on data_get_basket. Rows also carry `max_input_tokens` and `exceeds_max_input_tokens` — a row flagged true is still priced and still ranked, but that model would refuse the request. A long-context price ladder ascends by `from_input_tokens` and always has at least one rung: the first starts at 0 and restates the model's flat rate, so a model priced the same at every input size has exactly one rung and needs no special case. The rung is chosen by the whole input side of a request — prompt plus cache reads plus cache writes — over half-open ranges, so an input landing exactly on `from_input_tokens` takes that rung. Rung rates carry base_*/billed_* like every other price; only the flat rate enters the SCU index. Each rung carries the same {input, output} `provenance` pair as elsewhere: the first repeats the base price's mark; a higher rung is a catalogue number and takes on both directions the single mark the vendor quotes it under. `max_input_tokens` is the largest input the model accepts. It is null when the model declares no window of its own — not unbounded: the request-body ceiling still applies, there is just no per-model limit. Above a declared window the request is refused before it reaches the provider. A catalogue that cannot be read, or that does not list the model, errors this tool instead of quoting, because a cost silently computed at the flat rate would understate the long context the ladder exists to price. Returns the sorted list plus a grouping by family (e.g. openai.gpt, anthropic.claude). Covers index members only — for any other tracked model use compute_estimate, whose numbers are on the same basis. Use to answer 'which model is cheapest?' or 'how much would this cost on a different model?'.

Nominal USD cost for any oracle-tracked model given input/output token counts — index members and catalog-only models on identical terms. Cache reads and cache writes belong inside input_tokens and are charged at the full input rate here; no cache discount is applied. Returns `base_usd_cost` (provider list price), `routing_fee_usd` and `billed_usd_cost` (what compute.finance charges), plus the `routing_fee_rate` they derive from. Compare models on base_usd_cost; budget on billed_usd_cost. A `provenance` mark says how far a number has been checked: 'verified' — an operator recorded a vendor source; 'inferred' — derived from a sibling number or a vendor default, with no source recorded; 'promotional' — a discounted list price expected to end. Every value bills exactly as shown: the mark rates trust in the number, not the amount charged, and holds as of the operator's last pass rather than a live vendor check. `base_price_provenance` marks the input and output prices this cost is built from, populated for every tracked model. The cost is quoted at the rung input_tokens selects on the model's ladder, returned whole as `applied_context_tier` so the rate behind the number is visible; for every rung read `context_tiers` on data_get_price. A long-context price ladder ascends by `from_input_tokens` and always has at least one rung: the first starts at 0 and restates the model's flat rate, so a model priced the same at every input size has exactly one rung and needs no special case. The rung is chosen by the whole input side of a request — prompt plus cache reads plus cache writes — over half-open ranges, so an input landing exactly on `from_input_tokens` takes that rung. Rung rates carry base_*/billed_* like every other price; only the flat rate enters the SCU index. Each rung carries the same {input, output} `provenance` pair as elsewhere: the first repeats the base price's mark; a higher rung is a catalogue number and takes on both directions the single mark the vendor quotes it under. `max_input_tokens` is the largest input the model accepts. It is null when the model declares no window of its own — not unbounded: the request-body ceiling still applies, there is just no per-model limit. Above a declared window the request is refused before it reaches the provider. A catalogue that cannot be read, or that does not list the model, errors this tool instead of quoting, because a cost silently computed at the flat rate would understate the long context the ladder exists to price. `exceeds_max_input_tokens` is true when input_tokens is above `max_input_tokens`: the cost is still quoted, because a refused request is worth pricing before you reshape it, but the request as supplied would be rejected. `price_source` ('oracle-basket' | 'oracle-catalog') names the serving endpoint only and does not change the pricing basis, so two models with the same provider price return the same cost. Reasoning tokens are billed inside output_tokens, so this estimate adds no separate reasoning leg; read the model's reasoning price from data_get_price. Errors with 'Model not tracked by oracle' for unknown keys. Source: Oracle API (/v1/oracle/resolve + /v1/oracle/catalog). For a cost with the cache discount applied, use analyze_session on a real transcript. Models are identified by their canonical vendor-prefixed id ('anthropic/claude-sonnet-4.6', 'openai/gpt-5.5'); the bare name ('gpt-5.5') resolves to the same model, and the response echoes the canonical id. The vendor slug is not always provider.key (alibaba → qwen, xai → x-ai, moonshot → moonshotai), so pass an id the API returned rather than assembling one.

Frozen SCU denominator for the inverse computeIndex purchasing-power view: the SCU of the first confirmed revision (methodologyVersion 1), captured set-once and never changes. Source: Oracle API (/v1/oracle/baseline). The published computeIndex on /v1/oracle/scu, /v1/oracle/latest and each /v1/oracle/history point equals (baseline.scuUsd / point.scuUsd) × 100 — 100 at genesis, rises as compute gets cheaper. Returns null until the first revision is confirmed.

Every model in the current SCU index — provider, family (e.g. openai.gpt, anthropic.claude, google.gemini, xai.grok), base_* USD prices per million tokens (the provider list price), billed_* prices (what compute.finance charges), per-component cache pricing (cachedInput, cacheWrite5m, cacheWrite1h) and a `reasoning` block carrying `reasoningOutput` (the whole block is null when the model has no reasoning price), all priced on the same base. `routing_fee_rate` ships once at the top level; billed_* is null when the oracle does not publish it. Compare models on base_*; budget on billed_*. A `provenance` mark says how far a number has been checked: 'verified' — an operator recorded a vendor source; 'inferred' — derived from a sibling number or a vendor default, with no source recorded; 'promotional' — a discounted list price expected to end. Every value bills exactly as shown: the mark rates trust in the number, not the amount charged, and holds as of the operator's last pass rather than a live vendor check. `base_price_provenance` carries one mark for base_input and one for base_output, and every cache and reasoning component carries its own. `context_tiers` carries each model's long-context price ladder. A long-context price ladder ascends by `from_input_tokens` and always has at least one rung: the first starts at 0 and restates the model's flat rate, so a model priced the same at every input size has exactly one rung and needs no special case. The rung is chosen by the whole input side of a request — prompt plus cache reads plus cache writes — over half-open ranges, so an input landing exactly on `from_input_tokens` takes that rung. Rung rates carry base_*/billed_* like every other price; only the flat rate enters the SCU index. Each rung carries the same {input, output} `provenance` pair as elsewhere: the first repeats the base price's mark; a higher rung is a catalogue number and takes on both directions the single mark the vendor quotes it under. `max_input_tokens` is the largest input the model accepts. It is null when the model declares no window of its own — not unbounded: the request-body ceiling still applies, there is just no per-model limit. Above a declared window the request is refused before it reaches the provider. `context_tiers` is null — never a one-rung ladder — when the catalogue cannot be read or does not list the model, so an unknown ladder is never served as a flat price; `max_input_tokens` is null alongside it. Prices are the live catalogue figures the exchange bills, identical to what data_get_price serves for the same model: index membership decides which models are listed here, never what they cost. For the prices a published index revision attested on-chain — which may lag the catalogue — use data_get_cpi. Source: Oracle API (/v1/oracle/catalog). For a single model, use data_get_price instead.

Per-family blended-cost breakdown of the SCU — methodology-versioned discriminated union (keyed by methodologyVersion) with one entry per family representative (family, modelKey, inputPriceUsdPerMillion, outputPriceUsdPerMillion, blendedCostUsd). modelKey is the bare manifest key ('claude-opus-4.8'), not the canonical vendor-prefixed id — strip the vendor prefix off a catalog modelKey before joining on it. Source: Oracle API (/v1/oracle/scu.breakdown). Use to attribute SCU contributions to specific model families. For the full SCU response with reference workload, use data_get_scu instead.

Full catalog of tracked models — every model with a recorded price, including non-index entries. Source: Oracle API (/v1/oracle/catalog). Each entry carries modelKey (the canonical vendor-prefixed id, e.g. 'anthropic/claude-opus-4.8'), displayName, provider, family, indexMember flag (true if current family representative in the latest confirmed revision), currentPrice with input/output USD per million tokens and an observedAt timestamp, and per-component cache/reasoning blocks (`reasoning` is null when the model has no reasoning price). A `provenance` mark says how far a number has been checked: 'verified' — an operator recorded a vendor source; 'inferred' — derived from a sibling number or a vendor default, with no source recorded; 'promotional' — a discounted list price expected to end. Every value bills exactly as shown: the mark rates trust in the number, not the amount charged, and holds as of the operator's last pass rather than a live vendor check. currentPrice.provenance carries one mark per price for every model, index member or not, because these are catalogue rows rather than manifest figures; every cache and reasoning component carries its own. This tool passes the oracle document through unchanged, so its long-context fields keep the upstream shape: `contextTiers` is an ascending array of rungs above the flat rate, absent entirely on a model priced the same at every input size, and each rung carries one provenance mark covering both its directions; `maxInputTokens` is absent on a model that declares no window of its own — not unbounded: the request-body ceiling still applies, there is just no per-model limit. For the same ladder normalised so a flat model needs no special case, use data_get_price or compute_estimate. For basket-only display, use data_get_basket instead.

Full Compute Price Index — raw oracle response with the canonical vendor-prefixed model id, provider, family, raw and marked-up prices, scuUsd, revisionVersion, last-updated timestamp. The prices are the figures the latest published revision attested on-chain: they change only when an operator publishes a new revision, so they may lag the live catalogue and must not be quoted as what a model costs now — for that use data_get_price or data_get_basket. Source: Oracle API. Use this for the complete index data as attested. For the per-family blended-cost breakdown, use data_get_breakdown.

SCU index time series — date-range history of Standard Compute Unit values with optional bucketing granularity. Source: Oracle API (/v1/oracle/history). Each point carries scuUsd, methodologyVersion, revisionVersion, metadataHash, and computeIndex when populated. per-revision emits one point per revision; daily and weekly buckets carry the last revision's value forward across empty buckets (step-function close). Defaults to per-revision over the full range. For a single point at a specific timestamp, fetch the individual revision via data_get_cpi.

Methodology changelog — every registered methodology version with its formula summary, family rule, reference workload, and spec reference, plus activeVersion (the version in force now). Source: Oracle API. Use to interpret SCU values and to pin integrations to a methodology version.

Which models can serve a request right now — call it before choosing a model, so a model that cannot serve is ruled out before the request instead of after a 503. Source: Compute Finance API (/v1/models/availability). Carries `computedAt` (when the exchange computed this answer), `ttlSeconds` (how long it considers the answer fresh), `models` — an array of every catalogue model as `id`, the canonical vendor-prefixed id ('anthropic/claude-opus-4.8', 'openai/gpt-5.5'), plus a `routable` boolean — and `auto`, carrying the `id` the `auto` alias points at in this snapshot. The signal is advisory: it is true as of `computedAt` and only for `ttlSeconds` after it, capacity moves on its own, and a model reported routable can still fail the send — handle the error on the request itself rather than reading this answer as a guarantee. The answer is the exchange's own, served verbatim with no liveness computed here, so it cannot disagree with what the router does. It covers the public pool and takes no arguments. Says nothing about price: use data_get_catalog or data_get_basket for what the routable models cost and compute_estimate for the cost of the one you settle on.

Per-model input/output USD price effective at a specific timestamp. Source: Oracle API (/v1/oracle/models/{model}/price-at). Response is a discriminated union by source: 'manifest' when the model is the family representative in the revision active at that date (cross-links revisionVersion, methodologyVersion, metadataHash, family for verification), or 'catalog' when only catalog pricing exists (step-function fallback). The model is named by its canonical vendor-prefixed id ('anthropic/claude-opus-4.8'); the bare name ('claude-opus-4.8') names the same model. modelKey echoes the canonical id; manifestKey carries the bare key the attested manifest is keyed by and ships with every 'manifest' response. observedAt reflects when the price was recorded. Returns an error for malformed or future dates, untracked models, or dates preceding all available data.

Per-model input/output USD price time series — date-range history for any oracle-tracked model. Source: Oracle API (/v1/oracle/models/{model}/price-history). Each point carries input/output USD per million tokens, a source ('manifest' | 'catalog'), plus revisionVersion, methodologyVersion and metadataHash on attested points. Catchup revisions whose manifest is unavailable are surfaced in unavailableRevisions. Same granularity (per-revision/daily/weekly) and limit semantics as data_get_history. The model is named by its canonical vendor-prefixed id ('anthropic/claude-opus-4.8'); the bare name ('claude-opus-4.8') names the same model. modelKey echoes the canonical id; manifestKey carries the bare key the attested manifest is keyed by and ships whenever at least one point has source 'manifest'. Errors only when the model has neither an attested appearance nor a catalog price.

Price for a single oracle-tracked model — index members and catalog-only entries on identical terms. Returns base_input/base_output USD per million tokens (the provider list price), `routing_fee_rate`, and billed_* = base × (1 + routing_fee_rate) — what compute.finance charges. Per-component cache pricing (cachedInput, cacheWrite5m, cacheWrite1h) and the `reasoning` block carrying `reasoningOutput` (the whole block is null when the model has no reasoning price) are on the base basis. Every price is the live catalogue figure the exchange bills, so two models with the same provider price return the same numbers regardless of index membership. A `provenance` mark says how far a number has been checked: 'verified' — an operator recorded a vendor source; 'inferred' — derived from a sibling number or a vendor default, with no source recorded; 'promotional' — a discounted list price expected to end. Every value bills exactly as shown: the mark rates trust in the number, not the amount charged, and holds as of the operator's last pass rather than a live vendor check. `base_price_provenance` carries one mark for base_input and one for base_output, populated for every tracked model. Every cache and reasoning component carries its own mark. `context_tiers` carries the model's long-context price ladder. A long-context price ladder ascends by `from_input_tokens` and always has at least one rung: the first starts at 0 and restates the model's flat rate, so a model priced the same at every input size has exactly one rung and needs no special case. The rung is chosen by the whole input side of a request — prompt plus cache reads plus cache writes — over half-open ranges, so an input landing exactly on `from_input_tokens` takes that rung. Rung rates carry base_*/billed_* like every other price; only the flat rate enters the SCU index. Each rung carries the same {input, output} `provenance` pair as elsewhere: the first repeats the base price's mark; a higher rung is a catalogue number and takes on both directions the single mark the vendor quotes it under. `max_input_tokens` is the largest input the model accepts. It is null when the model declares no window of its own — not unbounded: the request-body ceiling still applies, there is just no per-model limit. Above a declared window the request is refused before it reaches the provider. `context_tiers` is null — never a one-rung ladder — when the catalogue cannot be read or does not list the model, so an unknown ladder is never served as a flat price; `max_input_tokens` is null alongside it. `price_source` ('oracle-basket' | 'oracle-catalog') names the serving endpoint only and does not change the pricing basis. Errors with 'Model not tracked by oracle' for unknown keys. Source: Oracle API (/v1/oracle/resolve + /v1/oracle/catalog). Models are identified by their canonical vendor-prefixed id ('anthropic/claude-opus-4.8', 'openai/gpt-5.5'); the bare name ('gpt-5.5') resolves to the same model, and the response echoes the canonical id. The vendor slug is not always provider.key (alibaba → qwen, xai → x-ai, moonshot → moonshotai), so pass an id the API returned rather than assembling one.

Historical index changes — each entry carries publishedAt, revisionVersion, methodologyVersion, scuBefore/scuAfter, a summary and the attesting txHash, plus a typed changes[] list (MODEL_ADDED, MODEL_REMOVED, PRICE_CHANGE, WORKLOAD_CHANGE). changes[].modelKey is the bare manifest key ('claude-opus-4.8'), not the canonical vendor-prefixed id — strip the vendor prefix off a catalog modelKey before joining on it. Source: Oracle API. Sorted most recent first. Use the optional limit parameter to cap results.

Current Standard Compute Unit (SCU) — value plus the methodology-versioned `breakdown` discriminated union listing every family representative with USD-per-million-token prices and blended cost. Also carries `computeIndex`: the inverse purchasing-power view (baseline / scuUsd) × 100, anchored at 100 at the first confirmed revision. The response carries methodologyVersion; see data_get_methodology for the formula in force. breakdown.familyRepresentatives[].modelKey is the bare manifest key ('claude-opus-4.8'), not the canonical vendor-prefixed id — strip the vendor prefix off a catalog modelKey before joining on it. For the breakdown alone, use data_get_breakdown; for the baseline denominator, use data_get_baseline. Source: Oracle API.

SCU value active at a specific timestamp via step function — no interpolation. Source: Oracle API (/v1/oracle/scu-at). Resolves the latest confirmed revision with publishedAt ≤ date and returns its scuUsd, scuUsd18, computeIndex, revisionVersion, methodologyVersion, publishedAt, and metadataHash. Monotonicity is non-strict — when two confirmed revisions share publishedAt the highest revisionVersion wins. computeIndex is derived as (baseline.scuUsd / scuUsd) × 100, the same formula as data_get_scu and each data_get_history point. Returns null when the date precedes the genesis revision; errors on malformed or future dates. Use data_get_history for a bucketed series; use data_get_scu_at for a single-point lookup.

Pre-formatted table of recent Claude Code sessions across all projects — per-session Prompts · Inferences · Tool calls, tokens, and effective/nominal cost. Source: local Claude Code transcripts + Oracle API. Print the `text` field verbatim. Defaults to last 24h, top 10.

Pre-formatted per-inference breakdown for cf-session-consumption skill. Source: local Claude Code transcript + Oracle API. Bar chart, tool aggregates, mechanical facts; one row per assistant reply (Innn). Header carries the canonical Prompts · Inferences · Tool calls triplet — same numbers as render_session_report and render_active_sessions. Print the `text` field verbatim. Pass full=true to show every inference instead of top-10/last-5.

Pre-formatted session cost report for cf-session-management skill. Source: local Claude Code transcript + Oracle API. Reads the transcript, prices it, logs to history, returns a `text` string. Header carries the canonical Prompts · Inferences · Tool calls triplet (user prompts, assistant replies, tool_use blocks — three distinct counters). Print verbatim — do not reformat or interpret. Omit session_id for the most recent session.

Aggregate stats across logged sessions (deduped, last-wins). Source: local ~/.compute-finance/ storage. Sample size, cumulative effective vs nominal cost, per-profile medians, insights (cache dominance). Insights require at least 5 sessions.