Turn published research into living, verifiable knowledge.

The reproducibility checklist and artifact links are read from the article itself, not asserted. And the runtime EXECUTES something: it recomputes the arithmetic each paper reports — a count against its percentage, an estimate against its own confidence interval — and reports what disagrees. Across 15 papers it executed 106 checks, reproduced 102, and found 4 articles that contradict their own numbers: three print an estimate that falls outside the interval reported with it — an estimate of 6 against [1.01, 1.1], 0.5 against [−0.7, −0.3], and −0.71 against a 95% interval of [−4.44, −3.39], which no rounding can make true — and one reports 508/3824 as 13.2% where the division gives 13.28%. Tolerance is the precision the paper itself wrote, so 17/30 as "57%" passes and "57.4%" does not. Two further checks returned `insufficient_data` rather than a verdict — an interval reported with no point estimate before it — and are counted as neither reproduced nor inconsistent. Pure arithmetic over numbers already extracted: no model, no network, 0.9 ms per LRO. Separately, the runtime can now EXECUTE a registered method in a locked-down container and check that it is reproducible: a Monte Carlo method over 300,000 samples ran twice through the HTTP API and produced byte-identical output.

The name this pillar used to carry — Executable Science Runtime — promised re-running the authors' analysis, and that is not what runs. No environment is pinned or rebuilt, no author code is executed, no figure is regenerated from data. That gap is not waiting on engineering: measured across the corpus, 0 of 12 papers report a random seed, hyperparameters, hardware or a compute budget, and only 2 declare that code exists anywhere — so a sandbox would have an empty input set. There is a REAL sandbox — a container with no network, a read-only root filesystem, an unprivileged user, no capabilities and hard ceilings, from an image pinned by digest, proven by attempting each forbidden thing and requiring it to fail. What is missing is not the runtime any more, it is the input: a paper that publishes no code, no seed and no environment gives a sandbox nothing to run. The in-process executor still provides no isolation, is labelled as such, and refuses any spec asking for a backend it is not. What the checks verify is internal consistency, which is a real and checkable property of a paper, and a narrower one than reproducibility — which is why this pillar is now named for the checks rather than for a runtime. The nightly skip that makes this affordable was itself the biggest risk to it: its cache key covered the paper's text and not the checking code, so adding a check left every paper skipped and the gate reported the corpus CLEAN over both errors it should have caught. The key now includes the checker.

Where a claim reports a comparison against an outcome, the edge is built from the extractor's structured measurement rather than from the sentence — 89 of 451 edges are derived this way and 52 carry a parsed effect with its confidence interval. Values the parser cannot read as a single number ("20%–30%; up to 50%") are refused with the reason rather than guessed. Every edge that asserts a relationship then carries an identifiability label computed by the back-door criterion over the graph: whether the graph names a set of variables that would block confounding, and when it does not, which reason applies. Every graph now also states its own SHAPE where it is drawn, because the count of asserted relationships says nothing about whether they connect: 3,602 of 4,099 graph variables touch exactly one relationship, so most of these graphs are a small traversable core inside a large fringe of separate observations. nearly every graph says so as a core-and-fringe, a few hold no path at all, and the reader is told which — along with the pipeline's own identifiability caveats, which were written on every row and rendered nowhere until now.

The label runs over the whole corpus and returns `unknown` for all 129 edges it applies to — every one for the same reason, that the treatment has no asserted cause — with 0 named confounders and 0 adjustment variables across twenty papers. That is the honest output of a correct implementation over papers that do not state what it needs, and it is exactly what a "causal knowledge engine" must not be sold as. The count went DOWN on purpose: an earlier pass counted variables a paper said a FUTURE study should adjust for, which is not an adjustment the paper made. No effect is estimated anywhere, by design — the numbers on edges are the ones the papers reported, never ones we computed. There is no do-calculus, no counterfactual query, and no cross-paper graph: each graph is per-paper, and only 50 of 4,099 variables carry an ontology id, so the graphs cannot yet be joined. The standalone `causal-engine` service is parked, not wired: its back-door check returns true for an empty adjustment set and it keys on a role every shipped graph leaves as "variable", so connecting it would produce confident wrong answers.

The Claim Auditor re-reads each claim against the evidence cited beside it. Both write to `ai_runs` and nothing else: findings are surfaced to a human, and no agent transitions a review state.

Coverage is per (agent, paper), not per paper. The figure beside this pillar used to be `lros_with_agent_runs` — papers carrying output from ANY agent — which one scheduled agent takes to 100% and holds there: it read 28 of 28 while four of the seven agents had run on a single paper. The metric measured the wrong claim, and an agent that never runs now counts against the denominator rather than being invisible. Three agents were registered, reachable by name, and never constructed by the app, so every run skipped them in silence; four more called a model with no ceiling applied, because the budget map named only two of them. Both are fixed and gated. `run_agents_over_corpus.py` runs the six over the catalog through the orchestrator's own use case and skips a paper already carrying a report for the same claim content, so a scheduled pass prices the delta rather than the corpus — a full pass is about 10,700 model calls at the registry ceilings. The Claim Auditor remains the expensive one at one call per claim. Every figure an agent emits is checked, including ones in a report's metadata: an agent that emitted no findings used to bypass the contract entirely, which let a computed meta-analytic pooled effect reach the API with no citation. No agent scores, and none transitions a review state — that is the contract, not a gap: agents write `ai_runs`, humans decide.

The copilot refuses an ungrounded answer. Measured on the corpus: 2,897 of 2,900 claims carry a verified snippet, and the one that does not is held in needs_review rather than published — the enforcement working, not an exception to it. Extraction asks the provider for JSON-schema structured output where it is supported, which tightens the SHAPE of a response and not its grounding.

The name this pillar used to carry — Zero-Hallucination Architecture — promised graph-constrained decoding, and that is not achievable as named: constraining a decoder requires logit-level control of the model, and extraction runs against a hosted model through LiteLLM, which exposes `response_format` and nothing finer. What is enforced instead runs AFTER GENERATION rather than during it: every claim's source span is verified against the document once the model has produced it, assembly strips any figure that cannot be traced to one, and the copilot refuses rather than answering. That is a weaker promise than constrained decoding and a checkable one — a sentence is admitted because it was checked, not because the decoder could not have written anything else. The claim is narrowed to that guarantee rather than dropped, and the landing page still marks the aspirational mechanism as a design rather than a running one. Anchoring is not total: a couple of claims carry no verified source span — one methodological, one a stated limitation — and the measured figure is the one shown beside this pillar rather than a number frozen into this sentence. Both are extraction misses rather than a design choice, and the strip-or-refuse guarantee still applied to them.

MeSH 2026 is the primary medical vocabulary — NLM publishes it free of charge for commercial use, and it is cached locally so resolution needs no network and costs nothing per paper. Which vocabulary applies is declared per domain in packs/vocabularies.json, so a new research field is a data edit; a paper whose domain has no licensed vocabulary records that reason rather than appearing to mention nothing. Europe PMC's text-mined UMLS, ChEBI, Gene Ontology and UniProt concepts are kept alongside, each labelled with the vocabulary it came from. UMLS is supported for an operator who holds a licence and its identifiers are withheld at serving otherwise, because NLM's terms prohibit redistributing UMLS subsets. A second node can be asked about any of them: /api/v1/federation/node and /api/v1/federation/claims are part of the product API, served by the same app that serves the read model.

Two independently administered deployments, operated by the SAME TEAM. `publisher-b` has its own signing key generated in its own home, its own three papers with no DOI in common with this repo's twenty, and its own trust store holding only the other side's public key — asserted before anything is demonstrated, because a demo printing “verified” while both sides share a key has demonstrated nothing. Every technical reason a third party could not be the second node is gone; what is left is a counterparty, which is a business relationship and cannot be manufactured. Do not say “two organisations” unqualified. It is JSON over HTTP — not GraphQL and not JSON-LD, both of which earlier copy named and neither of which is built. One concept at a time, by canonical id: there is deliberately no free-text search and no unfiltered listing, because an endpoint answering an empty filter is a bulk export wearing the shape of a query. There is no peer discovery, no rate limiting, and one shared secret for the whole endpoint rather than a credential per tenant. A signature proves who issued a claim, not that the claim is true, and it has no expiry — a claim retracted yesterday still verifies today, because there is no revocation and federation is unaware of time. The join surface is still thin: 50 of 4,099 graph variables carry an identifier, because extracted names carry modifiers — "persistent obesity I" — where ontologies hold bare terms, and resolving those automatically was measured and refused after an exact-label search matched "ComBat", a batch-correction algorithm, to a gazetteer place. Coverage is bounded by what the miner recognises (diseases, chemicals, genes, organisms): 940 of 2,900 claims carry a concept and the rest carry none, rather than being linked to something approximate. The node holds its rows in memory, so this suits a catalog that fits in one — ten million LROs needs the concept lookup to be a query.

Seventeen schedules run — retraction and correction polling, re-deposit detection, a bounded action drainer, causal adjustment backfill, arithmetic recomputation, reproducibility grading, watcher notification, catalog materialize, ledger sealing, a backfill for papers nothing has ever looked at, three rights sweeps, the corpus-shaped research agents, canonical projection, orphan-vector pruning and database maintenance — and `make schedules` reports 17 enabled and states each job's health, naming the ones that are FAILING or OVERDUE with the error rather than showing a count that is only true on the day it was written. Detection asks the registry what changed rather than asking each paper whether it did, scoped to the DOI prefixes we hold: about seven HTTP requests a day at ANY corpus size, where the per-paper design it replaced would need 10,000,000 a day at ten million LROs. Every paper carries a DATED registry observation — verdict, timestamp, source and the publisher's deposit stamp — recorded at ingest and refreshed by the loop, so the reader is told what was checked and when rather than being shown a clean tick that means nothing. A failing job never stamps a success timestamp, so it reports FAILING or OVERDUE rather than looking healthy, and it retries under an exponential backoff that is bounded rather than re-running every minute for as long as the failure lasts.

Nothing acts on a retraction — no LRO is unpublished or re-extracted when its paper is withdrawn — by design; the sweep records the notice and a human decides. Model spend is capped at one re-ingest per run, so a day with many changed papers drains over several days rather than in one bill; a ceiling DEFERS work and never drops it, and queue depth is reported every run so a backlog is visible rather than silent. Change detection reads Crossref's deposit record, so an article edited without a new deposit is not seen, and there is no citation ingest, no method drift detection and no guideline tracking — "a new paper contradicts this claim" is not a trigger. The work queue is a Postgres table with SKIP LOCKED claim semantics where a DSN is configured, and the JSON file elsewhere, so a deployment without a database still runs the loop.