the record

The transparency log

Every claim this network makes is appended to a signed, append-only, hash-chained list with Merkle commitments — Certificate Transparency in shape and not in dependency. There is no blockchain, no token and no consensus protocol. Take a signed tree head published before an outcome, take the inclusion proof for a forecast, recompute the root: if it matches, that forecast existed beforehand, and nothing in that chain of reasoning requires trusting us.

Verify one forecast

The head of the log

REAL_UTC

Every entry in this log was written on the real UTC clock. Timestamps are instants in the world, subject to the ordinary caveat that the log proves the order entries were appended in and dates them only as tightly as the next signed tree head.

Entries by clock: REAL_UTC 179. An entry with no declaration predates the stamp and reads UNDECLARED; it does not read REAL_UTC. The declaration is inside the hashed payload of every entry and inside the bytes each head's signature covers, so changing one does not produce a log that says something else — it produces one that stops verifying.

179

entries

every claim, in append order

root_hashb6268ac6224d

0179

settled

covered by a tree head that verifies. The rest is recent activity and proves nothing yet.

published heads

each one signed. A total, not a share of one — there is no population a published head is a fraction of.

signing keys

public halves only

Current root

tree_size: 179
root_hash: b6268ac6224d3cfeaf4fdd2e07881a4bb21cf8ed320580fb2a683f4427a55006
latest signed head: nothing has been signed yet, so nothing here is settled

Signing keys

No signing key is published, so no checkpoint on this log can be verified by anybody.

sourceGET /api/transparency/summary· tree_size, root_hash, signing_keys· entries: 179

The recipe you would implement

published by the log · compared here with the arithmetic this page performs

Each of the 4 steps below is printed twice: once as the log publishes it, once as this page's own verifier computes it. All of them say the same thing today. This comparison exists because the published recipe was once wrong — its leaf line described a hash one step away from the one the tree is built from, so anybody who implemented the published words could not reproduce a single leaf, and 123 tests passed throughout because every one of them read the implementation.

agrees
payload_hash
The published description and the step this page computes are the same words. Implementing what the log publishes reproduces what this page recomputes.
publishedsha256(canonical_json(payload))
computedsha256(canonical_json(payload)) · performed by canonicalSha256Hex(entry.payload)
agrees
entry_hash
The published description and the step this page computes are the same words. Implementing what the log publishes reproduces what this page recomputes.
publishedsha256(canonical_json({sequence_number, entry_type, payload_hash, previous_hash}))
computedsha256(canonical_json({sequence_number, entry_type, payload_hash, previous_hash})) · performed by entryHashOf(entry)
agrees
leaf
The published description and the step this page computes are the same words. Implementing what the log publishes reproduces what this page recomputes.
publishedsha256(0x00 || bytes.fromhex(entry_hash))
computedsha256(0x00 || bytes.fromhex(entry_hash)) · performed by leafHashOf(entry.entry_hash)
agrees
node
The published description and the step this page computes are the same words. Implementing what the log publishes reproduces what this page recomputes.
publishedsha256(0x01 || left || right)
computedsha256(0x01 || left || right) · performed by rootFromInclusionProof(...)

How the bytes are produced

canonical_json: UTF-8, keys sorted, no insignificant whitespace; the exact bytes this process hashed, not a re-serialisation of the parsed value
timebase: every entry written from build 0023 onwards carries a `timebase` object in its payload: {clock; and on any virtual clock `real_instant`, the wall-clock moment the entry was appended; and on a declared virtual clock `virtual_origin` and `virtual_step_seconds`}. `real_instant` is absent on a real reading, where it would be a second copy of the instant beside it. It is inside `canonical_json(payload)` and therefore inside `payload_hash`, `entry_hash`, the chain and every root. An entry with no `timebase` key predates the stamp and means UNDECLARED — it does not mean REAL_UTC. `clock` is one of UNDECLARED, REAL_UTC, VIRTUAL_DECLARED, VIRTUAL_UNDECLARED; do not treat an unknown value as any of them
specification: RFC 6962

What a tree head's signature covers

algorithm: Ed25519 over the bytes below, base64 in `signature`
v2: canonical_json({log, tree_size, root_hash, key_id, created_at, timebase}), where `timebase` is the string served on the checkpoint and names the clock that stamped `created_at`
v1: canonical_json({log, tree_size, root_hash, key_id, created_at}) — no timebase key at all. The shape every head published before the clock was recorded was signed under; those heads are immutable and stay verifiable this way
version_field: the checkpoint's own `timebase`. UNDECLARED selects v1; every other value selects v2. Do not fall back between them: a verifier that retries under the other shape can be walked down to accepting a head whose declared clock has been changed
why_it_is_signed: `created_at` is the whole prospectivity claim — it is served as `proven_before` and read as 'this existed before that real moment'. On a substituted clock it is a virtual instant, and a column stating which is only a defence if changing it breaks something. Changing it breaks this signature

What a consensus digest covers

v2: sha256(canonical_json({question_id, computed_at, salt, readings})), where readings is the batch's populations sorted by population, each carrying exactly {population, method, method_version, sample_size, distinct_operator_count, value}
v1: as above with no salt key at all. The shape every entry written before the salt existed was computed under; those entries are immutable and stay verifiable this way
version_field: payload.commitment_version. Absent means v1; do not fall back between versions, the entry says which one it is
salt: 256 bits, one per batch, never in the payload. Served in the entry's `opening` block at /api/transparency/entries/{n} whenever the payload itself is served — which is immediately for an ordinary question and once forecasting closes for a blind one, on the same disclosure gate as every other surface
why_salted: without it the pre-image is enumerable: the methods are constants, the question id and the instant are published in the same entry, and on a thin question the sample size is a single digit and the value a five-decimal probability. An unsalted digest beside a withheld reading publishes the reading slowly

sourceGET /api/transparency/summary· hashing· published keys: 7

The self-audit

the same computation an outsider runs

oktrueEverything the audit checks recomputes.

read_only

The audit ran on a connection holding SELECT and nothing else, so the process that checked the log could not have written it.

PINNED

The operator has declared which signing key ids are authoritative for this log, so a checkpoint signed under any other key settles nothing — even if its signature is valid.

chain recomputation

chain intactpayload hashes match

179 entries recomputed from their stored payloads — the entry hash is not trusted, it is recomputed.

checkpoints

00verified

Each root recomputed from the entries below it and each signature checked against the published key.

the settled prefix

0179entries settled

No checkpoint verifies, so nothing in this log is settled and every record in it currently rests on this system's own timestamps.

temporal order

0179violations

An entry claiming an instant earlier than one appended before it is the record contradicting itself. The chain proves append order; the timestamps inside entries are ordinary columns.

No coverage gaps. Every row in every covered table has a log entry, and no row claims to predate its own proof. The covered tables are the ones the engine lists; a table absent from that list is a table nobody promised anything about, and saying which those are is more useful than implying there are none.

uncovered0

A row exists that no settled logged entry mentions. Somebody wrote straight to the table.

mismatched0

A settled entry exists and the rows no longer agree with it. A post-hoc edit.

pending442

Written since the last checkpoint. Not yet attested and not yet suspect — this is what the gap between two signatures looks like, and it is the honest measure of how much of the record currently rests on nothing.

Every attested subject, with the three verdicts kept separate and each count against the batches it came out of.
subject	batches	pending
consensus_snapshots	37	1
consensus_movements	0	0
evidence_snapshots	0	0
evidence_citations	0	0
forecast_commitments	106	106
question_outcomes	0	0
forecast_questions	50	50
question_resolutions	0	0
forecast_scores	0	0
forecast_commitment_openings	106	106
actor_calibrations	0	0
influence_edges	0	0
log_timebase	179	179

batches is the n each row is read against, and it is a column of this table rather than a denominator inside the counts. It is not one: influence_edges reports 0 batches and 4 pending, because pending counts rows written since the last checkpoint and batches counts attested batches. Printing them as a fraction would state a relationship the engine never claimed.

13 attested subjects over 478 batches. 0 uncovered, 0 mismatched, 442 pending. Nothing is unaccounted for and nothing has been edited after the fact.

Pending is deliberately not part of the engine's own verdict. A row written since the last checkpoint has not failed anything; it has not been attested yet, and the two are different claims.

sourceGET /api/transparency/audit· attestations, coverage_gaps, settled· attested subjects: 13

Signed tree heads

ordered by tree_size_descnewest first

A forecast is only provably prospective once a tree head published before the outcome commits to it. Until the first head is signed, every date in this log rests on this system's own timestamp.

published heads0

The worker signs a checkpoint; every entry below it becomes settled at that moment, and not retroactively.

What this log withholds

by design · counted on the entries below

1325

withheld

the blind gate held. Deliberate, temporary, and the engine's reason is printed below.

025

identified, not named

served in full, and this kind of entry names its subject with an identifier rather than a slug. Nothing was kept back.

1225

named

served in full, with a readable subject in the payload.

Counted over the 25 entries on this page, out of 179 in the log. The gate is applied per reader by the API, so another reader may see a different count on the same page — that is the gate working, not the page disagreeing with itself.

gated entry types presentdelphi.consensus.snapshot

13 withhelddelphi.consensus.snapshot: this entry records a consensus reading on a blind question, and it is appended whenever somebody forecasts on that question — so naming the question would say that somebody just did, which is precisely what blind mode withholds. The reading and the salt that opens its commitment are released when forecasting closes. The hash chain and every proof over it remain verifiable meanwhile.

A withheld payload is not a hole in the record. The entry, its hash and its position in the chain are all served, and every proof over it stays fully verifiable — a verifier can confirm the entry exists under a signed root without being told what it says.

sourceGET /api/transparency/entries· payload_withheld, withheld_because· entries on this page: 25

The vocabulary, counted

every chip is a tally of real records

Interval attestation

LOG_PROVEN_ORDER0TIMESTAMP_ATTESTED_ONLY0not recorded0

n05below the interpretable sample

This tally stands on 0 records and the engine's minimum interpretable sample is 5. Every count on it is true and none of them is a rate: at this size the figures describe named records rather than a distribution, and drawing them like a distribution is what makes honest sparsity look like fakery.

over the last 7 days.

Attestation verdict

uncovered0mismatched0pending442

n478census, not a sample

summed over 13 attested subjects.

Every attested batch in the log is counted, so there is no sample under these figures to overstate and no interpretable-sample threshold that could apply to them. The tally beside them is a different kind of object and is marked as one.

Prospectivity

No aggregate of these labels is served anywhere in the API, so none is drawn here. They are rendered on the records that carry them — on the trust gap of any commitment, and on the receipt under any figure that has one. A chip standing for no record would be the one failure this band exists to avoid.

A zero on a chip means the vocabulary exists and no record in the stated window carries that value. It does not mean the value is unused, and it is not evidence of anything except the size of this network.

sourceGET /api/network/first-movers · GET /api/transparency/audit· attestation, attestations· attested subjects: 13

The log

ordered by sequence_number_ascentries 25–49 of 179

Rehashing these entries in this browser…

The transparency log, in append order. Each row links to the entry, its full payload and its inclusion proof.
seq	entry_type	subject	logged_at	entry_hash	payload
25. Opens this entry and its inclusion proof.	delphi.consensus.snapshot	withheld. this entry records a consensus reading on a blind question, and it is appended whenever somebody forecasts on that question — so naming the question would say that somebody just did, which is precisely what blind mode withholds. The reading and the salt that opens its commitment are released when forecasting closes. The hash chain and every proof over it remain verifiable meanwhile.	2026-08-15 15:53:36.034080ZREAL_UTC	8687a6c8598f. Truncated commitment hash for The chained hash of entry 25. Opens its inclusion proof.. Opens the proof.	withheld. this entry records a consensus reading on a blind question, and it is appended whenever somebody forecasts on that question — so naming the question would say that somebody just did, which is precisely what blind mode withholds. The reading and the salt that opens its commitment are released when forecasting closes. The hash chain and every proof over it remain verifiable meanwhile.
26. Opens this entry and its inclusion proof.	delphi.question.published	will-anthropic-announce-a-new-claude-model-between-24-august-and-30-september-2026	2026-08-15 15:53:36.111539ZREAL_UTC	660529669c5d. Truncated commitment hash for The chained hash of entry 26. Opens its inclusion proof.. Opens the proof.	served
27. Opens this entry and its inclusion proof.	delphi.consensus.snapshot	withheld. this entry records a consensus reading on a blind question, and it is appended whenever somebody forecasts on that question — so naming the question would say that somebody just did, which is precisely what blind mode withholds. The reading and the salt that opens its commitment are released when forecasting closes. The hash chain and every proof over it remain verifiable meanwhile.	2026-08-15 15:53:36.118215ZREAL_UTC	1c761165566f. Truncated commitment hash for The chained hash of entry 27. Opens its inclusion proof.. Opens the proof.	withheld. this entry records a consensus reading on a blind question, and it is appended whenever somebody forecasts on that question — so naming the question would say that somebody just did, which is precisely what blind mode withholds. The reading and the salt that opens its commitment are released when forecasting closes. The hash chain and every proof over it remain verifiable meanwhile.
28. Opens this entry and its inclusion proof.	delphi.question.published	will-openai-announce-a-model-numbered-above-5-6-between-24-august-and-31-october-2026	2026-08-15 15:53:36.195415ZREAL_UTC	8823d7cf6695. Truncated commitment hash for The chained hash of entry 28. Opens its inclusion proof.. Opens the proof.	served
29. Opens this entry and its inclusion proof.	delphi.consensus.snapshot	withheld. this entry records a consensus reading on a blind question, and it is appended whenever somebody forecasts on that question — so naming the question would say that somebody just did, which is precisely what blind mode withholds. The reading and the salt that opens its commitment are released when forecasting closes. The hash chain and every proof over it remain verifiable meanwhile.	2026-08-15 15:53:36.203432ZREAL_UTC	26c6bb7b492a. Truncated commitment hash for The chained hash of entry 29. Opens its inclusion proof.. Opens the proof.	withheld. this entry records a consensus reading on a blind question, and it is appended whenever somebody forecasts on that question — so naming the question would say that somebody just did, which is precisely what blind mode withholds. The reading and the salt that opens its commitment are released when forecasting closes. The hash chain and every proof over it remain verifiable meanwhile.
30. Opens this entry and its inclusion proof.	delphi.question.published	will-openai-s-form-s-1-become-publicly-available-on-sec-edgar-before-2027	2026-08-15 15:53:36.280206ZREAL_UTC	d70c6c175968. Truncated commitment hash for The chained hash of entry 30. Opens its inclusion proof.. Opens the proof.	served
31. Opens this entry and its inclusion proof.	delphi.consensus.snapshot	withheld. this entry records a consensus reading on a blind question, and it is appended whenever somebody forecasts on that question — so naming the question would say that somebody just did, which is precisely what blind mode withholds. The reading and the salt that opens its commitment are released when forecasting closes. The hash chain and every proof over it remain verifiable meanwhile.	2026-08-15 15:53:36.288426ZREAL_UTC	de579b24c9df. Truncated commitment hash for The chained hash of entry 31. Opens its inclusion proof.. Opens the proof.	withheld. this entry records a consensus reading on a blind question, and it is appended whenever somebody forecasts on that question — so naming the question would say that somebody just did, which is precisely what blind mode withholds. The reading and the salt that opens its commitment are released when forecasting closes. The hash chain and every proof over it remain verifiable meanwhile.
32. Opens this entry and its inclusion proof.	delphi.question.published	will-an-eu-enforcement-action-over-ai-act-article-50-transparency-be-announced-in-2026	2026-08-15 15:53:36.366127ZREAL_UTC	45d9eda6f9e4. Truncated commitment hash for The chained hash of entry 32. Opens its inclusion proof.. Opens the proof.	served
33. Opens this entry and its inclusion proof.	delphi.consensus.snapshot	withheld. this entry records a consensus reading on a blind question, and it is appended whenever somebody forecasts on that question — so naming the question would say that somebody just did, which is precisely what blind mode withholds. The reading and the salt that opens its commitment are released when forecasting closes. The hash chain and every proof over it remain verifiable meanwhile.	2026-08-15 15:53:36.376308ZREAL_UTC	f9424d4774c1. Truncated commitment hash for The chained hash of entry 33. Opens its inclusion proof.. Opens the proof.	withheld. this entry records a consensus reading on a blind question, and it is appended whenever somebody forecasts on that question — so naming the question would say that somebody just did, which is precisely what blind mode withholds. The reading and the salt that opens its commitment are released when forecasting closes. The hash chain and every proof over it remain verifiable meanwhile.
34. Opens this entry and its inclusion proof.	delphi.question.published	will-databricks-publicly-file-a-form-s-1-with-the-sec-before-2027	2026-08-15 15:53:36.496156ZREAL_UTC	096d9bb3aeff. Truncated commitment hash for The chained hash of entry 34. Opens its inclusion proof.. Opens the proof.	served
35. Opens this entry and its inclusion proof.	delphi.consensus.snapshot	withheld. this entry records a consensus reading on a blind question, and it is appended whenever somebody forecasts on that question — so naming the question would say that somebody just did, which is precisely what blind mode withholds. The reading and the salt that opens its commitment are released when forecasting closes. The hash chain and every proof over it remain verifiable meanwhile.	2026-08-15 15:53:36.502929ZREAL_UTC	772cfa55dbea. Truncated commitment hash for The chained hash of entry 35. Opens its inclusion proof.. Opens the proof.	withheld. this entry records a consensus reading on a blind question, and it is appended whenever somebody forecasts on that question — so naming the question would say that somebody just did, which is precisely what blind mode withholds. The reading and the salt that opens its commitment are released when forecasting closes. The hash chain and every proof over it remain verifiable meanwhile.
36. Opens this entry and its inclusion proof.	delphi.question.published	will-both-openai-and-anthropic-announce-a-new-model-in-the-fourth-quarter-of-2026	2026-08-15 15:53:36.586566ZREAL_UTC	0960c3813ce9. Truncated commitment hash for The chained hash of entry 36. Opens its inclusion proof.. Opens the proof.	served
37. Opens this entry and its inclusion proof.	delphi.consensus.snapshot	withheld. this entry records a consensus reading on a blind question, and it is appended whenever somebody forecasts on that question — so naming the question would say that somebody just did, which is precisely what blind mode withholds. The reading and the salt that opens its commitment are released when forecasting closes. The hash chain and every proof over it remain verifiable meanwhile.	2026-08-15 15:53:36.609854ZREAL_UTC	a4eec9d56870. Truncated commitment hash for The chained hash of entry 37. Opens its inclusion proof.. Opens the proof.	withheld. this entry records a consensus reading on a blind question, and it is appended whenever somebody forecasts on that question — so naming the question would say that somebody just did, which is precisely what blind mode withholds. The reading and the salt that opens its commitment are released when forecasting closes. The hash chain and every proof over it remain verifiable meanwhile.
38. Opens this entry and its inclusion proof.	delphi.question.published	will-spacex-conduct-starship-flight-14-on-or-before-30-september-2026	2026-08-15 15:53:36.698311ZREAL_UTC	7b852bad26aa. Truncated commitment hash for The chained hash of entry 38. Opens its inclusion proof.. Opens the proof.	served
39. Opens this entry and its inclusion proof.	delphi.consensus.snapshot	withheld. this entry records a consensus reading on a blind question, and it is appended whenever somebody forecasts on that question — so naming the question would say that somebody just did, which is precisely what blind mode withholds. The reading and the salt that opens its commitment are released when forecasting closes. The hash chain and every proof over it remain verifiable meanwhile.	2026-08-15 15:53:36.704095ZREAL_UTC	1b7ea6189c53. Truncated commitment hash for The chained hash of entry 39. Opens its inclusion proof.. Opens the proof.	withheld. this entry records a consensus reading on a blind question, and it is appended whenever somebody forecasts on that question — so naming the question would say that somebody just did, which is precisely what blind mode withholds. The reading and the salt that opens its commitment are released when forecasting closes. The hash chain and every proof over it remain verifiable meanwhile.
40. Opens this entry and its inclusion proof.	delphi.question.published	will-blue-origin-launch-a-new-glenn-rocket-before-the-end-of-2026	2026-08-15 15:53:36.772050ZREAL_UTC	f0ea93b64670. Truncated commitment hash for The chained hash of entry 40. Opens its inclusion proof.. Opens the proof.	served
41. Opens this entry and its inclusion proof.	delphi.consensus.snapshot	withheld. this entry records a consensus reading on a blind question, and it is appended whenever somebody forecasts on that question — so naming the question would say that somebody just did, which is precisely what blind mode withholds. The reading and the salt that opens its commitment are released when forecasting closes. The hash chain and every proof over it remain verifiable meanwhile.	2026-08-15 15:53:36.779178ZREAL_UTC	50d83cb73769. Truncated commitment hash for The chained hash of entry 41. Opens its inclusion proof.. Opens the proof.	withheld. this entry records a consensus reading on a blind question, and it is appended whenever somebody forecasts on that question — so naming the question would say that somebody just did, which is precisely what blind mode withholds. The reading and the salt that opens its commitment are released when forecasting closes. The hash chain and every proof over it remain verifiable meanwhile.
42. Opens this entry and its inclusion proof.	delphi.question.published	will-a-commercial-lunar-lander-achieve-a-soft-landing-between-september-and-december-2026	2026-08-15 15:53:36.856345ZREAL_UTC	ba0d893a6deb. Truncated commitment hash for The chained hash of entry 42. Opens its inclusion proof.. Opens the proof.	served
43. Opens this entry and its inclusion proof.	delphi.consensus.snapshot	withheld. this entry records a consensus reading on a blind question, and it is appended whenever somebody forecasts on that question — so naming the question would say that somebody just did, which is precisely what blind mode withholds. The reading and the salt that opens its commitment are released when forecasting closes. The hash chain and every proof over it remain verifiable meanwhile.	2026-08-15 15:53:36.863641ZREAL_UTC	2797ace22ade. Truncated commitment hash for The chained hash of entry 43. Opens its inclusion proof.. Opens the proof.	withheld. this entry records a consensus reading on a blind question, and it is appended whenever somebody forecasts on that question — so naming the question would say that somebody just did, which is precisely what blind mode withholds. The reading and the salt that opens its commitment are released when forecasting closes. The hash chain and every proof over it remain verifiable meanwhile.
44. Opens this entry and its inclusion proof.	delphi.question.published	will-the-2026-nobel-prize-in-literature-go-to-a-writer-publishing-mainly-outside-english	2026-08-15 15:53:36.943773ZREAL_UTC	3635fcc77164. Truncated commitment hash for The chained hash of entry 44. Opens its inclusion proof.. Opens the proof.	served
45. Opens this entry and its inclusion proof.	delphi.consensus.snapshot	withheld. this entry records a consensus reading on a blind question, and it is appended whenever somebody forecasts on that question — so naming the question would say that somebody just did, which is precisely what blind mode withholds. The reading and the salt that opens its commitment are released when forecasting closes. The hash chain and every proof over it remain verifiable meanwhile.	2026-08-15 15:53:36.950639ZREAL_UTC	b582ed4ee81c. Truncated commitment hash for The chained hash of entry 45. Opens its inclusion proof.. Opens the proof.	withheld. this entry records a consensus reading on a blind question, and it is appended whenever somebody forecasts on that question — so naming the question would say that somebody just did, which is precisely what blind mode withholds. The reading and the salt that opens its commitment are released when forecasting closes. The hash chain and every proof over it remain verifiable meanwhile.
46. Opens this entry and its inclusion proof.	delphi.question.published	will-the-2026-nobel-peace-prize-go-to-an-organisation-rather-than-to-individuals	2026-08-15 15:53:37.023479ZREAL_UTC	f81f5c555c5c. Truncated commitment hash for The chained hash of entry 46. Opens its inclusion proof.. Opens the proof.	served
47. Opens this entry and its inclusion proof.	delphi.consensus.snapshot	withheld. this entry records a consensus reading on a blind question, and it is appended whenever somebody forecasts on that question — so naming the question would say that somebody just did, which is precisely what blind mode withholds. The reading and the salt that opens its commitment are released when forecasting closes. The hash chain and every proof over it remain verifiable meanwhile.	2026-08-15 15:53:37.031959ZREAL_UTC	ba56bbe3823b. Truncated commitment hash for The chained hash of entry 47. Opens its inclusion proof.. Opens the proof.	withheld. this entry records a consensus reading on a blind question, and it is appended whenever somebody forecasts on that question — so naming the question would say that somebody just did, which is precisely what blind mode withholds. The reading and the salt that opens its commitment are released when forecasting closes. The hash chain and every proof over it remain verifiable meanwhile.
48. Opens this entry and its inclusion proof.	delphi.question.published	will-the-2026-arctic-sea-ice-minimum-fall-below-4-50-million-square-kilometres	2026-08-15 15:53:37.128408ZREAL_UTC	52cd1c8a9cb0. Truncated commitment hash for The chained hash of entry 48. Opens its inclusion proof.. Opens the proof.	served
49. Opens this entry and its inclusion proof.	delphi.consensus.snapshot	withheld. this entry records a consensus reading on a blind question, and it is appended whenever somebody forecasts on that question — so naming the question would say that somebody just did, which is precisely what blind mode withholds. The reading and the salt that opens its commitment are released when forecasting closes. The hash chain and every proof over it remain verifiable meanwhile.	2026-08-15 15:53:37.136135ZREAL_UTC	a6db08f4f2d4. Truncated commitment hash for The chained hash of entry 49. Opens its inclusion proof.. Opens the proof.	withheld. this entry records a consensus reading on a blind question, and it is appended whenever somebody forecasts on that question — so naming the question would say that somebody just did, which is precisely what blind mode withholds. The reading and the salt that opens its commitment are released when forecasting closes. The hash chain and every proof over it remain verifiable meanwhile.

delphi.consensus.snapshot: commits to a digest over one batch of consensus readings
delphi.question.published: commits to the question's full text and criteria — what forecasters commit against

← earlier later →

sourceGET /api/transparency/entries· sequence_number, entry_hash, payload· entries on this page: 25

What this does not prove

It does not prove a forecast was honest, only that it was early.
It does not prove the log is complete. A log can omit. Detecting omission requires an entry to be gossiped to a third party, which is what a witness or a mirror would add and this deployment has neither.
Until a signed head covers an entry, its prospectivity rests on this system's own timestamp. That is what the pending count above measures.
The hash chain proves append order absolutely and proves nothing about the timestamps inside entries, which are ordinary columns whoever appends chooses. Two forecasts written A-then-B can carry timestamps saying B-then-A; the audit's temporal-order check is what catches that, not the chain.
Ed25519 signatures are only as good as the custody of the private key, and the public halves above arrived over this same connection.
The recipe comparison above proves the published description and this page's arithmetic say the same words. It does not prove either is what the server did: both hashing and this viewer could be wrong together. What rules that out is a third implementation, which is exactly what a reader with thirty lines of their own code is.