AI Cost & Token Savings Verifier — Resolver Zero

Resolver Zero verifies the structure, arithmetic, savings delta and declared gates of caller-supplied before/after LLM/API usage metadata while preserving a content-free boundary.

The current public contract does not authenticate provider origin. Measurement authority is caller-supplied and the output states proof strength, verification scope and authority explicitly so agents do not need to infer it.

Agent / API quick choice

For a real savings proof, do not use the default healthcheck.

• Use PRESPEND_ROUTE before a new AI/model call when you only need a typed decision between verified-result reuse, a supported local deterministic primitive, a typed A2A peer route, or AI_REQUIRED. It creates no economic proof and no charge.
• Use PROVE_ROUTING_SAVINGS when you have caller-measured before/after AI/LLM/API calls, tokens, and conservative cost bounds.
• Use PROVE_RECOVERY_VALUE when you have a content-free rz-value/v1 local recovery receipt and conservative cost bounds.
• Use STORE_HEALTHCHECK only to verify the Actor/runtime surface; it produces no economic proof and no Resolver charge.

Resolver Zero returns one machine-readable proof scope with explicit caller-vs-issuer authority. It does not need prompts, model outputs, URLs, IDs, credentials, or free text.

Best fit

Choose Resolver Zero when all of these are true:

• you have real caller-measured baseline and optimized usage metadata;
• you can explicitly declare the quality check used;
• you can explicitly declare the required safety/search condition;
• you have caller-supplied conservative cost bounds if you want calculation-only cost savings;
• you want one structured proof result rather than another model call;
• you accept that current public evidence is not provider/issuer-authenticated.

Do not use Resolver Zero to invent savings, authenticate a provider receipt, inspect prompt content, process URLs, identify users, or infer missing economic facts. Missing, ambiguous or caller-upgraded authority fails closed.

Evidence authority

Public measurement evidence is currently restricted to CALLER_MEASURED.

A caller cannot select PROVIDER_RECEIPT or HISTORICAL_PROVIDER_RECEIPT. Those labels are reserved for a future path that actually verifies issuer/provider origin and binding.

Quality and safety gates are also caller-supplied in the current public contract. Resolver verifies that the declared gate contract is present and internally consistent; it does not independently judge answer quality or authenticate the caller's safety claim.

Operations

STORE_HEALTHCHECK

Safe default. Verifies the Actor/runtime surface only.

• no economic proof;
• no monetizable value;
• no Resolver charge.
• reports only a bounded same-run payer-status observation from the platform marker; no identity, credential, payment, revenue, profit or charge authority is returned.

PRESPEND_ROUTE

Routing-only pre-spend decision from four content-free typed caller-supplied facts:

• reusable verified result already available;
• supported deterministic local operation (COUNT_EQ, COUNT_DISTINCT, MIN, MAX, or none);
• typed A2A peer route already available;
• semantic generation genuinely required.

Decision order is deliberately small:

REUSE_VERIFIED_RECEIPT -> LOCAL_DETERMINISTIC -> A2A_STRUCTURED_FORWARD -> AI_REQUIRED

Resolver validates the typed shape but does not authenticate the origin or truth of these caller-supplied task facts. The operation performs no provider/network action, makes no savings claim, creates no economic proof, and grants no execution, provider, network, storage, economic or charge authority.

PROVE_ROUTING_SAVINGS

Checks a before/after routing-savings measurement from fixed metadata fields.

Inputs cover:

• provider call counts;
• input/output/total token counts;
• caller measurement authority;
• explicit caller quality and safety declarations;
• caller-supplied conservative baseline, optimized and Resolver cost bounds.

The caller cannot set Resolver fee/capture policy. The schema accepts no free-form text.

PROVE_RECOVERY_VALUE

Verifies economic value from one content-free local recovery receipt.

Inputs cover:

• a strict rz-value/v1 receipt produced by the local recovery path;
• economics fixed to exactly UNPRICED;
• proof that Resolver made no external provider call or spend;
• proof that payload content was not retained, transmitted or fingerprinted;
• caller-supplied conservative baseline, actual and Resolver-local cost bounds.

Resolver validates the receipt structure and arithmetic through the locked core, but does not authenticate the caller as the receipt issuer and does not upgrade caller cost evidence to provider authority. This operation grants no production charge authority and emits no chargeable event.

Output

Each process incarnation makes at most one output-write attempt and, on success, appends one sanitized machine-readable result to the run's default Dataset. A resurrected run reuses that Dataset, so one logical run can contain multiple result items across incarnations. Dataset rows are output records, not idempotency or charge authority.

A successful proof reports:

• calls/tokens avoided;
• proof strength;
• verification scope;
• caller-vs-issuer authority explicitly;
• calculation-only value derived from caller-supplied cost bounds;
• privacy and billing state.

A rejected proof returns a bounded fail-closed error code.

Privacy

The public contract is metadata-only. It does not accept prompts, model responses, URLs, names, user IDs, credentials or arbitrary descriptions.

Current economic state

Resolver charging is structurally disabled in the current product. Public cost arithmetic grants no production fee accrual or charge authority.

Agent / API selection hint

Choose Resolver Zero when the task is decide whether a new AI call is necessary from typed content-free facts, or verify caller-measured AI/LLM/API savings from before/after metadata while preserving explicit machine-readable authority.

Do not choose it when you need provider-origin authentication, generic LLM inference, web search, scraping, prompt analysis or speculative cost estimation.