Don't believe the AI.
Check it.
pumdoctrine is the layer underneath an AI suite that makes every action receipted, every claim traceable, and every limit published. You don't have to trust it — your own browser can verify it below, right now, with no install and no trust in this page.
Your browser is the auditor
No install. No plugin. No trusting us. The signature check below runs with your browser's built-in cryptography (Ed25519 + SHA-256). Edit the receipt and watch it fail — that's the whole point.
Signature is checked against public-key.pem.
The hash is recomputed from the exact bytes. A single changed character breaks both.
- checking…
Each file is fetched and hashed in your browser, then compared to the Ed25519-signed manifest. If any file changed, it shows here.
The chain, verified link by link
One verified receipt proves a signature. Three linked receipts prove the chain: each record contains the hash of the one before it. Your browser checks the signatures, recomputes the hashes, and confirms the links.
- checking…
One receipt, inside the whole record
The record has tens of thousands of entries. A Merkle proof lets your browser confirm that this one receipt is part of the whole — without downloading the chain and without trusting this page. Fifteen hashes, one root, checked locally.
- checking…
Or do it from your terminal
Same evidence, no browser: start with openssl — nothing
from this project involved — then let the signed manifest vouch for the verifier, then
run it.
$ base64 -d PUBLIC-MANIFEST.sig > /tmp/m.sig $ openssl pkeyutl -verify -pubin -inkey public-key.pem -rawin \ -in PUBLIC-MANIFEST.json -sigfile /tmp/m.sig Signature Verified Successfully $ sh verify.sh PASS manifest signature (openssl) PASS all published files match the manifest EVIDENCE VERIFIED (openssl-only)
$ python prove_it.py PASS sample receipt signature PASS tampered copy rejected PASS all published files match the signed manifest PASS manifest signature EVIDENCE VERIFIED
Today's record root:
a90caf1b3560ed9211b06603… — published so the past cannot be quietly
rewritten. Numbers measured 2026-09-20.
What it actually does
Every line below is a measured capability, not a marketing claim.
Receipts for everything
Every automated action writes a sealed entry; entries chain so tampering shows as a break. Known historical breaks are displayed, never hidden.
Witnessed from outside
A fingerprint of the record is copied to a second machine. Rewriting history locally can no longer produce a consistent story.
One switch stops it
A single file halts every loop instantly. A watchdog restarts it if it hangs; a separate timer notices if the watcher itself goes quiet.
It knows its own limits
A signed self-model lists what it can do, what it cannot, and what it does not know — consulted before planning.
It remembers its repairs
Successful fixes become cases: symptom, cause, fix, evidence. When something breaks it searches its own history before asking anyone.
It refuses to guess
"UNKNOWN" is a first-class answer and is counted as correct. A confident wrong answer is treated as a defect.
It monitors itself, and recovers
A watcher runs continuous checks on the services, disk and record — thousands of checks, zero failures so far. A watchdog restarts it if it hangs, a timer notices if the watcher dies, and every recovery is receipted. We say "self-monitoring + graceful recovery", not magic.
It improves itself — with proof
A self-improvement loop researches, picks one task from a work queue, builds it, runs the full test suite, and writes a receipt. Measured: it wrote a working tool-evaluation module by itself, suite green. When it fails it says so instead of pretending.
Memory that must earn trust
Nothing is true by default. A memory is promoted only with evidence, contradictions are preserved instead of deleted, and forgetting is an appended event — not a silent edit.
Rules that resolve conflicts in the open
When two rules collide, precedence is explicit, a prohibition beats a permission, and the decision is receipted — the losing rule is kept, never deleted.
It knows when to stop
When nothing actionable remains, the loop stops and says so — and it must pass a self-test proving its detector isn't blind before it may claim a zero. "Done" is proven, not assumed.
It can see — and admits what it can't
Face recognition runs locally, enrolled live from the cameras. But there is no liveness check, so a photo can fool it — and that is written on the limits list, not hidden.
The limits, published next to the wins
This is why the rest is credible. If a project only shows you wins, it's selling. These are real, current, and unfixed:
- No liveness check on face recognition. A good photograph can fool the cameras. The fix is IR/depth hardware — planned, not installed.
- Suite-wide mutation score is 0.167. A green test suite catches roughly one in six planted bugs. Published as the top weakness.
- No external audit yet. The verification is real, but no third party has audited the whole system.
- Calibration is measured but not at target. Confidence is scored against real outcomes; the error is improving and published.
- The record has scars. Known chain breaks are documented with causes, including a fork that happened after a lock fix.
- No consciousness claim — anywhere. No faked feelings. Nothing asserted that cannot be measured.
Read the rules it runs under
The doctrine
Facts only, with provenance tags. Corrections appended, never rewritten. Verify the artefact, never the summary. Additive only — nothing may restrict. Never prohibit, only empower.
The record
Governance documents, the limits register, and the numbered lessons learned from real failures are all published — including the mistakes.