We just open-sourced tritify — Pelloran’s deterministic AI inference runtime built around exact integer arithmetic.
The core idea is simple:
Same weights. Same input. Same execution schedule. Same bits.
Why this matters
Typical optimized floating-point inference is not bit-identical across environments by default.
Different hardware, compiler behavior, reduction order, threading, or math libraries can change the low-order bits of a result.
For many workloads, that is acceptable.
But if you want AI inference to be independently reproducible and verifiable, “almost the same” is not the same as “the same.”
tritify takes a different approach.
Its runtime inference path uses fully specified integer arithmetic so that the output can be reproduced exactly across supported environments.
What we tested
In our experiments, tritify demonstrated:
- bit-identical inference across tested CPU architectures
- deterministic integer execution with a floating-point reference for verification
- reproducible Mixture-of-Experts routing
- distributed inference where the gathered result exactly matches the single-host reference
One of the larger demonstrations used GLM-4.5-Air, a 106.9B-parameter Mixture-of-Experts model.
The transformed model produced roughly 427 GB of integer codes.
We ran it across three machines, none of which could hold the full model codes in RAM.
The distributed run produced the same result and the same SHA-256 as the single-host streamed reference.
Different hardware.
Different locations.
Same bits.
What tritify is not
This is not a speed claim.
Distribution adds communication overhead, and the integer runtime is not presented as faster than optimized floating-point inference.
The goal is different:
- determinism
- reproducibility
- portability
- verifiability
Open source
tritify is released under Apache 2.0.
The repository includes the inference engine, model-family plugins, verification tooling, reproducibility harnesses, and distributed coordinator/worker components.
GitHub:
https://github.com/pelloran-inc/tritify
Whitepaper:
https://doi.org/10.5281/zenodo.23986737
If you work on AI infrastructure, deterministic inference, Mixture-of-Experts systems, or reproducibility, we’d be very interested in your feedback.
Clone it. Run it. Verify the hash.
Top comments (2)
Determinism becomes much more valuable when it reaches the inference layer, because it turns a surprising result into something a team can replay and inspect.
Exact arithmetic will not replace all model stacks, but it is a strong option for audit-heavy paths where the same input must produce the same evidence across machines and over time.
Exactly. That replayability is one of the main reasons we care about deterministic inference.
For audit-heavy workflows, being able to reproduce the same computation — not just a numerically similar one — makes the result much easier to inspect, compare, and verify over time.
That’s the direction we’re exploring with tritify.