LIVEWARE
Software that's alive.
Prove it yourself.
One page, one small living system, and a button for every claim. It grows from a signed seed, defends itself, packs data without losing a byte, links two tabs with no server, and re-runs our money-back guarantee — and each result is a receipt that GitHub's own computers reproduce. Nothing you run is sent anywhere.
What it is, in plain words: a public test bench for software that makes big claims. Instead of asking you to trust us, every claim on this page runs the real code in your browser and hands you a fingerprint of the result — a receipt — that you can check against an independent run on GitHub. Memory and self-improvement are still being built; they are marked IN BUILD below, with no green light, until they have buttons too.
Every claim on this page is a button. Every button gives you a receipt. GitHub's servers run the same tests and get the same answers.
Start here
No install, nothing to sign up for. You need only this browser tab — and, for the mesh test, a second one.
- Press “Run every test” at the top, or scroll to any test and press its own button. Every test runs here, on your computer, on plain CPU. Nothing is uploaded — you can switch your network off after the page has loaded and it still works.
- Watch the scoreboard (“Your run, live”, just below). Each card turns green when its test passes on your machine and red if it fails — a failure is shown, never hidden. Before you press anything, the cards show the verdict GitHub's run published; pressing a test's button runs it again here.
- Read the receipt under each test. A receipt id is a SHA-256 fingerprint of everything the test fed in, everything that came out, and the verdict. Change any of it — one byte — and the fingerprint changes completely. “Your receipt” is the one your browser just worked out; “expected” is the one committed to the public repository. They must match. Compression is the one exception, and it says so: zstd and brotli can't run inside a browser, so its receipt is GitHub's, and your browser re-measures LIGHT and gzip live and checks LIGHT's size against GitHub's row.
- Check it against GitHub's own run. Open the latest gate run, open the step that starts “the four receipts re-derive”, and find each test's verdict and the first twelve characters of its receipt. For the seed test the expected receipt starts … GitHub's computer worked that out on its own, from the same code — not from our machine.
- Try to break it. Tamper one byte of the seed, throw the attacks and the swarm at the door, send a fake peer to the second tab, change an exam answer under the guarantee. Every attack should be refused at a named check, and every tamper should change the receipt. If one gets through, it shows — and that is the result.
- Look under the hood. How it works walks the loop step by step, the blueprint lists every piece of code with its own test and mutation-gate result, and the white paper sets out the method and its limits.
- Re-run it all yourself, off this page. Clone the repository and run the three commands under How the proof works. You should get the same receipts again, on your own machine.
- Thinking of it for your business? Adoption says what it does for a team, and For business works out what one of your processes costs today, from your own numbers.
The AI industry runs on “trust us.” Liveware runs on “don't trust us. Break it.”
Your run, live. Green means it passed on your machine, and each receipt should match the expected hash. If anything doesn't, it shows here — never hidden.
Watch it race the industry standard PROVEN · receipt
Pick a file, or drop in your own. Liveware's LIGHT compression goes head to head with gzip, zstd and brotli — live, on your machine. Then it unpacks back to the exact original, byte for byte, and proves it with matching fingerprints.
| Sample | Original | LIGHT | gzip | zstd | brotli | Round-trip |
|---|
Big wins on structured data like agent logs and memory. Smaller wins on prose. Already-compressed files barely move, for anyone. We show all of it, because the honest table is the one you can believe.
measuring…
Proves: a compact, lossless codec that beats the standard tools on real data and restores byte-for-byte. Doesn't claim: that LIGHT wins on every kind of data (shown per type), or that it is fast — it's a context-mixing coder, slower than gzip and zstd, and the time is shown.
A whole system grows from one small file PROVEN · receipt
Plant the seed. Liveware checks its signature, then grows the full working system right here in your browser. The system writes out a perfect signed copy of itself. Change one byte and it refuses to grow.
Proves: it reproduces, and only verified copies live. Doesn't claim: it never spreads on its own — every copy is your choice, and whoever holds the signing key can sign a new seed.
Attack it. We'll show you every punch it stops PROVEN · receipt
Forged signatures. Replayed messages. Poisoned files. Oversized inputs. Ten thousand random attacks. A swarm that changes its shape every shot. Liveware checks everything before it reads anything, names the exact check that stopped each attack, and recognises repeat offenders on sight — and a genuine signed message still gets straight through, so you know it isn't just refusing everything.
Proves: defence that learns, by structure — it gets harder to fool the more you hit it. Doesn't claim: protection if someone steals your keys or your device. That's a different layer.
Open a second tab. Watch them connect PROVEN · receipt
Two living copies find each other directly, with no server in the middle. They share state, hand work across, and stay in sync even when you edit both at once. Inject a fake peer and watch it get shut out.
Proves: a living network with nobody in charge and nothing to switch off. Doesn't claim: a second device without a relay (same-browser tabs here), or large-scale mesh performance. First contact is trust-on-first-use.
It only gets paid if it beats what you use now PROVEN · receipt
This is our money-back guarantee, run for real on public data. An AI on our own machine read labelled examples once and wrote rules. Plain code kept only the rules that held up on data the AI never saw, then sat a final exam nobody had touched. The guarantee's engine compared the result with the simplest answer you'd get without us, and signed the verdict: charge due if it won, charge waived if it didn't. Three runs are on the record — two lost, one won. Press the button and your browser redoes everything after the AI, and has to land on the same signed receipts.
The order is the real order. After the two car runs lost, we picked a dataset where single clues can carry the answer — the case this method is built for — wrote that plan down and published it, then ran it. Each run has one completed AI reply: the first attempts at runs 2 and 3 hit our time limit before the AI answered, so nothing came back to choose between. The losses weren't deleted or re-rolled; they're the first two cards. Sealed means the plan and the pass mark were published on GitHub before the run; result is the outcome, published after. Click either to read it. Your browser fetches only this page's own files — the pinned data and the recorded runs — and sends nothing anywhere.
| Rule the AI wrote, kept by the gate | In plain words | Right on the check | Applied |
|---|
What the AI actually wrote — recorded once, unedited
open to load…
Classroom data, not advice. The dataset's own notes say there is no simple rule for telling whether a mushroom is edible — never eat a wild mushroom on the strength of a rule.
A receipt is only worth something if nobody can quietly change the result underneath it. Change the exam and watch.
- Pin public data, split it once. Two public datasets from the UCI Machine Learning Repository, fingerprinted by SHA-256 so nobody can swap them, shuffled once by a fixed seed: half to learn from, a quarter to check rules on, a quarter held back as the final exam.
- The AI teaches — once. A seven-billion-parameter model on our own machine (qwen2.5:7b, no cloud) reads 40 labelled examples and writes rules like “gill colour is buff → poisonous” (one it really wrote, and one the gate kept). Models don't repeat themselves word for word, so its reply was recorded the one time it answered. That is the one step you can't re-run here, and this page doesn't pretend you can.
- The gate keeps only what holds up. A rule survives only if, on the check split, it applies often enough (15 times; 12 for combined rules) and is right at least 80% of the time. Everything else is thrown out, in the open.
- The exam decides. The surviving rules — plain code, no AI, free to run on any computer — answer the final exam. The baseline is the simplest thing you could do without us: always guess the commonest answer.
- The guarantee signs. The baseline agreement was fixed before the work. It says “due” only if the rules beat the baseline by at least 8 percentage points, on the whole exam, by a clear statistical margin (a two-proportion z-test at z ≥ 1.96 — about 95% confidence that the gain is not luck); otherwise “waived”. The receipt is a SHA-256 fingerprint of that sealed test and both scores — change either and it changes.
The audit trail is public. Every run leaves one: the sealed plan, the AI's recorded reply, the result, and its receipt, each a public commit on GitHub that can't be altered afterwards without changing its fingerprint. And a third party re-checks it: GitHub's own runner re-derives this exact receipt on every change to this page, and fails the build if it doesn't match.
Proves: the guarantee says “due” only when a delivery beats the signed baseline on data nobody used to build it — and says “waived” when it doesn't, twice, on the record. Every number re-derives in your browser, and changing the exam changes the receipt. Doesn't claim: that the AI step re-runs here (it was recorded once), or that it will beat your baseline — two of these three didn't. The mushroom rules are classroom data, not advice.
Wave 2 — being built in the open
These are the next five organs. Their design is real and each is a sealed test elsewhere in the estate — but they do not have a live button on this page yet, so there is no receipt to show, and we will not paint a green we can't hand you. Each one lights up here, with its own re-runnable receipt, the moment its sealed test lands — exactly like the four above. This is the whole point: a claim with no button lives here until it has one.
It gets smarter — but only when it can prove it IN BUILD
Each new generation has to beat the last on data it has never seen. If it can't, it's thrown out, right in front of you. Then a final exam it never trained on checks the gains are real.
Will prove: self-improvement that can fail, with the failures on show. Won't claim: unlimited or general intelligence.
No button yet → no receipt. Lands here as a live, held-out-data test when its gate passes.
Close the tab. Come back. It remembers IN BUILD
Tell it things, restart your browser, and it's all still there with a matching fingerprint. Ask a question in your own words and it finds what it knows by meaning, with where every memory came from. Change one stored byte and it knows. Export the whole memory, open a fresh tab, and it comes back exactly as it was.
Will prove: memory that lasts, recalls by meaning, and can't be quietly altered. Won't claim: more than the stored, signed record holds.
No button yet → no receipt. Lands here when the persistent, tamper-evident vault passes its sealed test.
Code, software and AI, working as one IN BUILD
Paste in a messy email, invoice or note. An AI on your graphics card reads it, strict checks make sure what it pulled out is valid, a verified core makes the decision and shows its reasoning or says “I don't know,” the AI explains it in plain English, and it's saved to memory with a receipt — arriving in your second tab. Run it again: the wording may change, the decision never does.
Will prove: AI that can't make things up where it matters, running entirely on your machine. Won't claim: anything the verified core didn't decide.
No button yet → no receipt. Needs WebGPU; skipped and marked where absent, never faked.
Aligned by structure — we switch the safety off so you can see it work IN BUILD
Seven ways agents go wrong: making things up, using tools nobody approved, marking their own homework, claiming success without evidence, overstating results, acting on big decisions alone, inflating their own scores. Watch each get blocked. Then flip the gates off and watch the bad behaviour happen. Flip it back — that's how you know it's the structure doing the work, not luck.
Will prove: these specific failures are blocked and caught, with a gates-off control. Won't claim: that alignment is solved, or that the system has values.
No button yet → no receipt. Lands here with its gates-on / gates-off control run.
The same job, done faster on your own machine IN BUILD
Runs an AI job twice on your graphics card: once from scratch, once reusing what it already worked out. See the work saved and the time saved, measured on your hardware — its precise definition written before the test.
Will prove: measured reuse of prior work, on your GPU. Won't claim: a speed-up where your browser has no WebGPU — there it's skipped and marked.
No button yet → no receipt. Lands here when the measurement is defined and sealed.
How it works
Five moves, one loop. A signed seed grows the system; a door on the raw bytes defends a deliberately naive core; LIGHT keeps everything small and lossless; a mesh lets two copies find each other with no server; and every step writes a receipt anyone can re-run. The organism grows, defends, compresses, meshes and proves — then reproduces a verified copy of itself. Each panel below ends with a line from GitHub's published run of that step.
Magic, length, a LIGHT-encoded genome (every block pinned by SHA-256), a seal, and an Ed25519 signature over everything but itself. It checks magic, length, decode, shape, seal, signature, then each block's hash — only then does a block load.
—
A signed-packet door checks size, magic, version, length, dictionary, sender, signature and replay counter on the raw bytes before the body is decoded. Every refusal mints two antibodies: the exact bytes, and their shape.
—
A context-mixing arithmetic coder — seven models blended by weights that learn as they go, integer-only so encoder and decoder agree bit for bit on every engine, and lossless back to the original.
—
Each tab has its own key; they meet over the browser's channel (trust-on-first-use pins the key), then every message is a signed LIGHT packet checked against that key and a replay counter, with one shared document merged by a conflict-free law.
—
The blueprint — how it's built, piece by piece
Every box below is a file in the public repository. The page and GitHub's harness import the very same test bodies; the test bodies are built from small kernels; the kernels stand on code copied byte for byte from two other repositories and pinned by SHA-256. Each piece's test and mutation-gate figures below are read live from the gate receipt GitHub's run re-derives on every change — none is typed in.
reading the gate receipt…
Each file is copied byte for byte from the commit named, and a test in the suite fails the build if any byte differs from its pin or if anything sits in vendor/ unpinned.
| File | What it is | From | SHA-256 |
|---|
The mutants the gate lets through, and the written reason for each
How the proof works
The pass criteria were written and committed before any code that measures them. The measurement refuses to run if the sealed file changed, and the commit is on this page. Each new test is sealed on its own file, the same way.
Each test writes a record of its inputs, outputs and verdict; its id is the SHA-256 of that record. Your run's id must match the expected id shown beside each test.
GitHub Actions runs the same tests headlessly on every change and publishes the receipts. A third party reproduces the result, not just us.
The witness plants a bug in every kernel and fails the build unless a test catches it — proof the tests are real, not decoration. Failures are kept on the record, never hidden.
Clone the repo and run the same tests on your own machine, or check the public runs on GitHub. The pass rules were written and locked before any code existed.
git clone https://github.com/sjgant80-hub/liveware cd liveware node --test test/*.test.mjs # the kernels node tools/measure.mjs --check # re-derive the receipts, byte for byte node tools/measure-t11.mjs --check # the guarantee: three runs re-derived, every receipt attacked
What your browser can run
We check what your machine supports. Anything it can't run is skipped and marked — never faked.
detecting what your browser can run…
The white paper — the method on one page
1 · The problem
AI software is sold on claims a buyer can't check: benchmark scores nobody else can re-run, demos nobody is allowed to break, and “trust us” on where the data goes. A claim that only its maker can reproduce is marketing, however true it happens to be.
2 · The method
- Seal the test first. The pass criteria are written and committed before any code that measures them exists (CLAIMS.md, and CLAIMS-T11.md for the guarantee). The harness refuses to run if a sealed file has changed since the commit that sealed it, so the goalposts can't move after the result is known.
- One test body, run in two places. Each test is written once and imported both by this page and by the harness on GitHub's runner. What your browser runs is the code that was gated, not a demo of it.
- Receipts, not screenshots. Each run writes a record of its inputs, its outputs and its verdict; the receipt id is the SHA-256 of that record as canonical JSON. Two runs agree exactly when one short string agrees.
- Tests that can fail. The witness mutation gate plants a bug in every kernel and fails the build unless a test catches it. A mutant may be let through only with a written, checked reason — and the gate's own figures are a receipt GitHub re-derives.
- Losses stay on the record. Weak compression rows, the two guarantee runs that lost, and every “doesn't claim” stay on the page beside the wins.
3 · The results, as GitHub's run published them
- reading the receipts…
4 · The limits
- The guarantee's AI step is not re-run here: a model's reply is not reproducible word for word, so it was recorded the one time it answered. Everything after it re-runs.
- The mesh joins tabs in one browser. A second device needs a relay and is not claimed. First contact is trust-on-first-use.
- The door does not protect stolen keys or a stolen device — that is a different layer.
- LIGHT is smaller, not faster: it is slower than gzip and zstd, and the time is shown.
- Wave 2 — memory, self-improvement, the thinking organism, structural alignment, cache reuse — is not proven on this page. It is marked IN BUILD, with no green light, until each piece has its own sealed test and button.
- The guarantee's data is public classroom data. Beating a baseline there says nothing about your process until your own baseline is signed and your own exam is sat.
5 · Why it matters to a buyer
When the test is sealed before the work and the result is a receipt anyone can re-run, the buyer stops having to judge the supplier and only has to judge the test. That moves the risk to where it belongs: on the work, not on the trust.
The long version, every piece in plain English: EXPLAINER.md. The code, the sealed claims and the receipts: github.com/sjgant80-hub/liveware (MIT).
Adoption — what it does for your team, and how you roll it out
Liveware is the proof that the method works. What a business takes from it is the method itself: on one of its own processes, in its own engineering, or in how it buys software.
Pick one repeated, structured process you already measure. The test and the fee are signed before any work; the system is built on your hardware; a re-runnable receipt says due or waived. Nothing is paid on a promise. The cost case and the full roll-out are in For business.
Everything here is MIT and can be copied: commit the pass criteria before the code, have each test write a record whose SHA-256 is its receipt, run the same test bodies in the browser and in CI, and put a mutation gate in front of every kernel — the witness is the one used here.
Use this page as the checklist you ask every supplier to pass: re-run the receipts, read the sealed claims and their commit dates, check the vendored pins, and read each “doesn't claim” line before signing anything.
- The repeated part moves; the judgement stays. The owned system takes the share of one process that is decided the same way every time. Open-ended judgement stays with your team.
- No new AI tool to learn. What ships is a small set of readable rules running on your machines — no chat window, no prompts, no seats.
- Every result can be checked. Your team, your auditors or GitHub's runner can re-run any receipt and get the same answer.
- One process at a time. Each new process gets its own signed baseline and its own receipt — the same way this page adds each Wave 2 organ only when its own sealed test passes.
Put the guarantee to work on one of your processes
mint-a-department turns one painful, repetitive process into a small system you own — on your hardware, with no per-seat or per-call rent — and you pay only if a signed receipt shows it beats what you use now, on the measure you agreed before any work began. The engine is the one you just watched run in the guarantee. Liveware grows into a company one process at a time; this is the first one.
- Pick one painful process.
- We agree how you'll measure it.
- We build it on your own hardware.
- You get a signed receipt showing it beats what you use now.
If it doesn't beat what you use now, you don't pay.
That promise is the engine in the guarantee above — the same signed baseline agreement, run three times on public data, losses included. Your process gets the same treatment: your data, your current tool as the baseline, the agreement signed before any work. The fee is written into that agreement before anything is built, beside the number it has to beat — and your data stays on your own machines.
mint-a-department's own design notes, in its home repository: mint/README.md.
Your numbers, our method. Staff time at the UK median wage with no on-costs added — a floor, not a top end. Inflation on every later year. Every price from its published source, listed below. Change any input.
| Route | What happens | A year | Over the period |
|---|
Where every figure comes from
Find out whether AI pays in your business on one process you choose, with one number and one signed answer. The downside is capped: if it doesn't beat today, the charge is waived.
A cost that only appears on proof. No seats and no per-call meter; once it's yours, the running cost is the electricity of a machine you already own. The receipt behind the invoice is re-runnable, not a slide.
Measured against how your team works today, on your own data, with your current tool as the baseline — not against a strawman. It takes the repeated, structured part of one process; nothing else changes shape.
It runs on your hardware and calls no outside AI service to decide a case. What ships is a small set of fixed, readable rules — no model in the loop at answer time, so nothing drifts and nothing leaks. Every result has a SHA-256 receipt anyone can re-check.
You pick the process and the measure that matters to you. The test is written down and signed before any work, so the result can't be argued afterwards — by either side.
It takes the part of the job that is the same every time. Open-ended judgement isn't what it's built for, and it stays with your people.
- Nothing leaves at run time. The finished system decides each case on your machine and calls no AI service, so there is no outside processor to vet — data protection by design (UK GDPR Article 25).
- The build runs on your hardware too. The teaching step reads your job's data where it already is, as the local model did in the demo above. If a job ever calls for a teacher that can't run on your machines, that is agreed in writing before any data moves — and so is who touches your data during the build, and how.
- Auditable by anyone. Every kept rule can be printed and read, like the ones in the demo above. Every verdict is a receipt over the signed test and both scores.
- This page practises it too. Its Content-Security-Policy lets it load and contact only its own files — no third-party scripts, no analytics, no outside connections — so a file you drop in here, or a figure you type into the cost case, has nowhere to go.
- The code it stands on is pinned. Every piece copied in from elsewhere is held to its SHA-256, and the build fails if one byte differs — the blueprint lists each pin.
- You own what's delivered. It runs on your hardware; the code is MIT — no licence fee, no lock-in — and it keeps running without us.
- Support, service levels, warranty and liability are agreed per deployment, in that deployment's agreement.
- No meter to switch off. There are no seats and no per-call billing in the system you own.
- Intake. You name the process, the data it uses, the tool or method you use now, and the number it hits today. That's the intake form.
- The baseline agreement. Before any work: the measure, your current level, the smallest gain that counts, how much test data it needs, the confidence bar — and the fee. Both sides sign. The goalpost can't move after.
- The build. The teacher reads your job's data once and proposes rules; the gate keeps only the ones that hold up on data held back from it — exactly as in the demo. Hardware: nothing special. The finished rules run on any computer, and the demo's seven-billion-parameter teacher ran on an ordinary laptop processor (an Intel Core i7-1255U — no graphics card used).
- The verdict. The system sits the agreed test on data it never saw, and the signed agreement decides: a re-runnable receipt, due or waived.
- Live. On “due”, the owned system takes the routine share of the process on your hardware; your team keeps the rest.
- What if it doesn't beat what we use now?
- Then the charge is waived. The same engine said exactly that twice in the demo above, on the record.
- What if the AI makes things up?
- There is no AI at answer time. The AI proposes rules once; a rule survives only if it holds up on data it never saw, and you can read every one that survives.
- Couldn't the numbers be massaged afterwards?
- The test is signed before the work, and the receipt fingerprints that test and both scores. Change either and the receipt stops matching — try it in the demo above.
- Is a mushroom demo relevant to us?
- The data is a public classroom set so that anyone can check it. The mechanism — signed baseline, gate, held-back exam, receipt — is exactly what runs on your process.
- What if our process changes?
- The rules are fixed and readable, so nothing changes behind your back. A changed process gets a fresh baseline and a new agreement.
- Is the charge one-off or ongoing?
- The system you own has no seats and no per-call meter, so nothing in it bills you as you use it. The fee — and any support you choose to add — is set out in the agreement before any work, beside the number it has to beat. Nothing is charged that isn't written there.
- Which process should we start with?
- One that is repeated, structured and decided the same way every time — sorting, routing, triage, checking forms against rules — with a number you already track. Work that needs open-ended judgement is the wrong first choice, and we'll say so at intake.
- Can we check the receipt ourselves?
- Yes. It is a SHA-256 fingerprint of the signed test and the two scores; anyone holding those recomputes it exactly, as your browser did in the demo above and as GitHub's runner does on every change to this page.
- Are you certified — ISO 27001, SOC 2, Cyber Essentials?
- No certification is claimed on this page. What you can check instead is the evidence itself: the sealed tests and their commit dates, the receipts your own browser re-derives, the mutation gate's figures and the pinned code — and the finished system runs on your hardware, inside your own security controls.
- Who has used it?
- The three runs on this page are the public record — two lost, one won, every one re-runnable. No customer case studies are published here, and none is implied.
- Is the exam a fair sample of our real work?
- It is agreed test data from your own records, set aside before the build starts, and the build never sees it — the same separation the demo shows, where changing every exam answer leaves the kept rules untouched.
Supplied by AI Native Solutions. Start at ai-nativesolutions.com, or write your process and its baseline down on the intake form.
FAQ
Is this real or a demo?
Every claim on this page runs live in your browser and gives you a receipt you can check. The same tests run publicly on GitHub and get the same answers.
Does any of my data leave my device?
No. The page works offline once loaded. Files you drop in are processed locally and never uploaded.
Why do you show the tests that fail?
Because a record that includes its losses is one you can believe. The compression rows where LIGHT barely wins stay on the table; any failed claim stays on the page.
Do I need a powerful computer?
Most tests run on any modern browser, on plain CPU. The AI tests (Wave 2) need a browser with WebGPU; if yours doesn't have it, they're skipped and marked.
What is “teacher distillation”?
A large AI model (the teacher) is used once, at build time, to propose rules from examples. Plain code then keeps only the rules that hold up on data the teacher never saw. What ships is small, fast and fixed — it runs on any computer, needs no AI to answer, and costs nothing per use. The expensive model is paid for once, not on every request.
When I press re-run, does the AI run again?
No, and we say so plainly. A model's reply isn't reproducible word for word, so the teacher's reply was recorded the one time it answered, and committed with the result. Your browser re-runs everything after that — reading the rules, the check, the exam, the signed verdict — and must land on the committed receipts. You can read the recorded reply on the page.
Why show two runs that lost?
Because a guarantee that can't say no is worthless. On the car data the AI's rules didn't beat the simple baseline, so the charge was waived — twice. Those runs stay on the page beside the one that won, with their own sealed commits.
Can I use this for my company?
Yes. Start with one process and a signed baseline — see “For business” above.
Is it open source?
Yes. The code is MIT — the licence is in the repository — and so is fall-kit, where the vendored kernels come from. The public datasets and the sample files keep their own terms; the UCI datasets are credited below.
What is a receipt, exactly?
A record of what a test fed in, what came out and its verdict, written as canonical JSON (keys sorted, so the same record is always the same bytes). The receipt id is that record's SHA-256 fingerprint. Change one byte of the inputs, the outputs or the verdict and the id changes completely — which is why matching ids mean matching runs.
Who checks the checker?
The witness mutation gate. It plants deliberate bugs in each kernel, one at a time — turns a > into >=, an && into ||, a return true into return false — and fails the build unless a test catches every one. The blueprint shows each kernel's figures, read from a gate receipt that GitHub's run re-derives on every change.