Calibration Ledger — who has actually been right?

Give it a claim from an institution — a forecast, a guidance range, a dated promise — and it answers with that institution's record on claims like it: how far off they've been, how often the outcome fell inside the band they gave, and the evidence for every number. Organizations only, never people. Nothing is guessed: when the record is too thin, the answer is no coverage, and that answer is free.

Sources graded so far: FOMC Summary of Economic Projections · Philadelphia Fed Survey of Professional Forecasters (six variables, reproduced exactly against the Fed's own published error tables) · OECD Economic Outlook (15 variables, 61 economies, 59 editions since 1996) · IMF World Economic Outlook · ECB Survey of Professional Forecasters · US corporate guidance from 8-K exhibits, resolved against first-print XBRL actuals · dated corporate promises from newswires.

What you get with every answer: sample size and distinct target periods, mean error, RMSE, empirical 70%/90% intervals with bootstrap confidence bounds, band hit rates, the source's own printed actuals versus independent vintages, and a claim id you can verify — it returns the SHA-256 of the source bytes and where the value sits in them.

Modes: text (paste a sentence), lookup, score, compare, issuer, coverage (free), verify (free). Works as an Actor run, via API, and in Standby for agents.

Honesty rules baked in: declared coverage on every response; intervals refused below 10 distinct targets; extreme-regime cells flagged; cross-institution disagreements flagged; no person is ever a source. Every source's attribution rides along with the answer. Underlying data is available free from the publishers; this Actor sells its own analysis.

Example input (the prefill): {"mode": "lookup", "source": "oecd_eo", "series": "RGDP_GROWTH_A", "geo": "CAN", "target_period": "2027", "point": "1.8", "published_at": "2026-06-01"}. That is one lookup event, the cheapest paid answer.

Limits and data freshness: the image bundles a snapshot of the published serving copy (serving.sqlite, plus coverage.json when present) taken at build time. A run answers from that snapshot first, so the first answer never waits on a download. A background etag check against the published copy then runs. Until it finishes, or if the hub is unreachable, answers come from the bundled snapshot. Every answer's _provenance.ledger names the etag and file time it was served from. coverage mode reads the bundled coverage.json when it sits beside the snapshot. A new snapshot ships with the next Actor build.

Output: one dataset item per run: the answer itself, and the same object is the OUTPUT record. That holds for the free statuses too: a no_coverage, unparsed or insufficient_history item carries the full answer (reason, nearest_coverage, attribution). The demand log for those answers is kept separately, in the run's DEMAND key-value record, not in the dataset. Fields of a lookup item:

Field	Meaning
status	ok (a record was served, charged), or a free status: no_coverage, unparsed, insufficient_history, error, charge_limit_reached
claim	the claim as read: source, series, geo, target_period, point, published_at, horizon_days, horizon_bucket
record	the source's track record at that horizon: n, n_targets, mean_error, mae, rmse, error quantiles (p05…p95), share_over, uncertainty (bootstrap CIs), window, vintage, rule, interval_reliable, cross_check_flags, largest_misses
interval_70, interval_90	empirical intervals around the claimed point
bias_adjusted_point	the point corrected by the source's mean error
mean_error_ci90, rmse_ci90	90% bootstrap bounds
reading	one plain-language sentence
_provenance	ledger (repo, file, etag, file time served from), policy, mode, attribution, notice, billable_event, and charged plus charge_id (present only when the charge succeeded)

Example item (shortened) for the example input:

{"status": "ok",
 "claim": {"source": "oecd_eo", "series": "RGDP_GROWTH_A", "geo": "CAN", "target_period": "2027", "point": 1.8,
           "published_at": "2026-06-01", "horizon_days": 578, "horizon_bucket": "15-24m"},
 "record": {"n": 26, "n_targets": 26, "mean_error": -0.728, "mae": 1.344, "rmse": 2.057, "window": ["1998", "2024"],
            "interval_reliable": true, "largest_misses": ["…"]},
 "interval_70": [0.06, 2.52], "interval_90": [-2.33, 3.53], "bias_adjusted_point": 1.07,
 "mean_error_ci90": [-1.396, -0.173], "rmse_ci90": [1.124, 2.833],
 "reading": "oecd_eo: 26 resolved RGDP_GROWTH_A claims over 26 distinct target periods for CAN at this horizon; …",
 "_provenance": {"mode": "lookup", "ledger": {"file": "serving.sqlite", "etag": "abe0caf7…"},
                 "attribution": ["Source: OECD Economic Outlook (© OECD, CC BY 4.0)."],
                 "billable_event": "lookup", "charged": "lookup", "charge_id": "<run id>-lookup-<epoch ms>-<hex6>"}}

Pricing (pay per event, USD): lookup $0.02 · score $0.02 · text $0.03 · compare $0.05 · issuer $0.05. At most one of these per answer, and only when status is ok. coverage, verify, errors, malformed input and every free status above are not charged. The pricing table also lists actor-start at $0.005; this code does not emit that event.

Billing: the paid event is charged before the item is written (charge first, serve second). charged appears on the item only when that charge succeeded. If your spend limit has no room, nothing is charged and a free charge_limit_reached item is written instead of the record. If the charge is refused or fails, the record is withheld, a free error item (charge_refused / charge_failed) is written, and the run's status message says CHARGE_FAILED. Every charge gets a charge_id (<run id>-<event>-<epoch ms>-<hex6>), logged as CHARGE event=… charge_id=… before the charge is sent. If the item cannot be written after a successful charge (each write is checked; after a successful charge the push is tried twice more; every retry is safe: a retry is blind only when the request never reached the server (connection refused, DNS failure, HTTP 429), otherwise the dataset is first checked for the item by its charge_id (item count as fallback) and a found item counts as served, and when that cannot be told nothing is retried, so a run never writes the record twice), the run fails with DATASET_WRITE_FAILED_AFTER_CHARGE; the log line, the run's status message and the OUTPUT failure item all carry that charge_id (the failure item also keeps the billed answer under record), so a billed-but-unserved answer can be found and refunded. If a free item cannot be written, the run fails with DATASET_WRITE_FAILED. If the serving copy is unavailable, you get a free error item naming the fault (SERVING_*) and the run exits cleanly. In Standby, the reply waits for the charge with no client-side timeout (a sent charge is never abandoned): a charge that lands, however slowly, serves the record; only a charge that is refused or fails withholds the record, and a free charge_failed error is returned instead.