Why we built audit manifests in Rust, not Python.
The non-obvious choice that made bit-for-bit reproducibility actually possible — a deep dive into determinism, type safety, and what regulated AI demands of its substrate.
Everyone agrees AI decisions in regulated industries should be reproducible. Almost nobody builds the substrate that makes it true. We chose Rust for the one part of the stack where "close enough" is a compliance failure.
A forecast is a claim. In a regulated firm, a forecast is a claim someone may have to defend in front of an examiner. The question that matters is not "was it right?" — it is "can you reconstruct, exactly, how you got there?" If you cannot, the forecast is indefensible, regardless of whether it happened to be correct.
That single question shaped almost every architectural decision in DEINO. This post is about the one that drew the brightest line: we wrote the audit-manifest substrate in Rust, and we did not write it in Python. Not because Rust is faster. Because reproducibility is a property of the substrate, and Python makes it optional.
Reproducibility is not a feature you bolt on
The manifest we are building — BR-842, a per-output hash-chained, append-only ledger — has one job: attest that a given output can be replayed bit-for-bit, years later, and produce the identical bytes. Provenance is the easy half; the hard half is that the computation itself must be deterministic. A manifest that records a non-deterministic computation is a signed lie. It attests to something that cannot be reproduced, which is worse than no manifest at all.
A manifest that records a non-deterministic computation is a signed lie. It attests to something that cannot be reproduced.
Non-determinism hides in the boring places: hash-map iteration order, floating-point reductions across threads, time-of-day seeds, allocator layout that leaks into serialized output. Python lets all of these through without a word. The language treats deterministic execution as a coincidence the runtime happens to provide, not a guarantee it owes you. Rust treats it as something you can reason about, because the memory model and the concurrency model are explicit.
Where the boundary actually runs
We did not rewrite the world. The boundary is sharp and small: the ledger, the manifest builder, and the versioned GNL store — the parts whose output is the thing an auditor reads — are Rust. The parts that are inherently non-deterministic — the LLM calls, the agent swarm, the ingest of live feeds — are wrapped, not rewritten. You cannot make an LLM deterministic; you record what it said, with what model, at what version, against what inputs. Determinism is for the substrate; provenance is for the model.
Type safety is part of the audit story
An auditor reads a manifest to answer a question: "did the system that produced this output behave the way its spec says?" That question is easier to answer when the spec is executable. Rust’s type system encodes invariants — a NodeVersion is a NodeVersion, an AxisOverride is an AxisOverride, an AuditManifest is not a byte string — that a Python dict cannot. A malformed manifest is a compile error here, not a runtime surprise at the audit.
- Determinism is a property of the substrate; provenance is a property of the model. The manifest bridges them.
- The ledger, manifest builder, and GNL store are Rust. The LLM and swarm are wrapped, not rewritten.
- Type safety turns "did the system follow its spec" into something a compiler checks, not something an auditor infers.
What this costs, and what it buys
Rust is slower to write than Python in the first month and faster to defend in the third. For a platform whose entire value proposition is "you can reproduce this in front of a regulator," the third month is the only one that matters. We are pre-revenue and building the POC — but the POC exists to prove that the reproducibility claim survives scrutiny, and that is the claim Rust was chosen to make true.
We do not certify that the forecast was correct. We certify that the computation is reproducible. The first is a promise no honest system can keep; the second is a property of the substrate, and it is the one regulators actually ask for.
— BR-842 design note
The honest version of "AI you can trust"
Trust in regulated AI does not come from accuracy. Accuracy is a calibration loop in progress, and we will publish ours against a disclosed baseline only when Gate 1b passes. Trust comes from reproducibility: the ability to show your work, exactly, to anyone who asks, years later. That is what the manifest is for, and that is why the substrate that builds it had to be one where determinism is not a happy accident.
Python is a fine language for many things. Reproducible audit infrastructure for regulated AI is not one of them. Not because Python cannot do it — because it does not have to, and a substrate that does not have to will eventually not.