One option is to distribute the model across several computers.

But there is an important distinction:

You are not running several independent AIs.

You are running one model, split across multiple machines, working together as one inference system.

Think of it like a very large book

Imagine a book so large that one person cannot comfortably hold the whole thing.

Instead of giving everyone a full copy, you divide the book into sections.

Each person holds only one section.

When a particular piece of information is needed, the request goes to the person holding that section.

Their answer is then combined with the rest of the process.

That is a useful way to think about distributed model execution.

With tritify, different machines can hold different parts of the model.

Each machine computes only the part it is responsible for.

From the user’s point of view, it still behaves like one AI system.

Why split a model across machines?

The most obvious reason is memory.

Some models are simply too large to fit into the memory available on a single computer.

By distributing the model, several smaller machines can cooperate to run something that none of them could hold alone.

But once computation is distributed, another question appears:

How do you know the distributed run is still the same computation?

Why determinism matters

Many inference systems rely heavily on floating-point arithmetic.

Small differences in hardware, execution order, libraries, threading, or parallel computation can lead to slightly different numerical results.

For many applications, that is perfectly acceptable.

But if the goal is reproducibility and verification, “almost the same” is not enough.

tritify approaches this differently.

Its inference path is built around deterministic integer execution.

The goal is that the same model, the same input, and the same execution schedule can reproduce the same result — bit for bit.

That makes it possible to compare a distributed execution directly with a reference run.

Not approximately.

Not visually.

By hash.

The core idea

One model.

Split across multiple machines.

Each machine holds only its part.

Together, they execute one inference.

And the result can be reproduced and verified.

That is the idea behind tritify.

Open source

tritify is open source.

GitHub:
https://github.com/pelloran-inc/tritify

Whitepaper:
https://doi.org/10.5281/zenodo.23986737

One model. Multiple machines. One reproducible result.

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.

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.