// TECHNOLOGY
Floating point re-rounds a dot product once per term, so the answer depends on the chip, the thread count and the batch. Anomly's arithmetic rounds once, at the end. That single change makes AI computation deterministic across hardware and lets every result carry a receipt an independent party can re-execute.
The research behind it 5-DST: time is a place, not a line. What Anomly was built to compute. Three dimensions of time, two of space. Explore ▸Operands are posits with a bounded exponent (b-posit), so every product is exactly representable in a fixed-width accumulator called a quire. Sums are exact and order-independent; only the final readout rounds.
A length-N dot product carries no accumulated rounding error. Catastrophic cancellation, the failure mode that flips signs in float32, cannot happen inside the accumulator.
On an RTX 5090 the exact accumulation runs on the INT8 tensor-core path at 1.00 to 1.33x the throughput of BF16 matmuls. Exactness is not a speed tax.
Fine-tuning with constant 8-bit operands on the exact path matches a bf16 twin's quality across seeds, at bf16 wall-clock, with four times fewer operand bits per multiply.
Exact matmuls plus a deterministic elementwise library (norms, softmax, activations, rotary embeddings) make the whole transformer graph bit-identical on x86 CPUs, NVIDIA CUDA and ARM. Every evaluation can then be committed to a receipt.
An open spec: a canonical manifest of digests (runtime, weights, prompt, parameters, output) whose SHA-256 is the certificate; receipts chain into an append-only worldline.
Two reference implementations, in Python and in Go and sharing no code with the runtime, replay a served answer from the weights and the prompt and compare float32 bits, including the tokenisation.
A chain’s genesis binds to platform attestation (SEV-SNP, TDX, NVIDIA CC, TPM); entries are signed by a TPM-resident key; SCITT statements and a transparency log make the record public without leaking prompts.
The product: an OpenAI-compatible local endpoint for llama.cpp and Ollama models where every inference writes a receipt, plus the verifier that checks them. Apache-2.0.
The arithmetic is not a software emulation waiting for hardware. The same design has been proven at every level we can reach.
A 625-processing-element exact GEMM on a Xilinx Alveo U200, bit-exact against the software oracle, verified by drand-challenged sampling.
First SKY130 tapeout delivered and brought up on our bench. The exact-quire core is verified bit-exact, including cancellation cases, against the bonded netlist; the production respin is designed and verified.
Core datapath blocks are machine-proven correct for all inputs, not only tested; the proofs caught a real clamp bug before silicon.
Exact-quire kernels run on Tenstorrent Blackhole and on NVIDIA tensor cores, so the arithmetic ships on hardware customers already own.
This is a capability difference, not a speed difference. It pays where being provably right is worth more than being approximately fast.
Law, health, finance, government: a receipt per answer, verifiable after the fact by a party that does not trust the operator.
Order-independent accumulation makes distributed gradient reductions bit-reproducible, so a training run can be replayed and checked step by step.
When a model writes code or moves money, the worldline is the flight recorder: which model, which input, which output, provably.
Ill-conditioned sums, covariance, geometric predicates and orthogonalised optimisers, where float rounding changes the answer and the quire does not.
Certify a model on one machine and serve it on another with the same bits, including CPUs, GPUs, ARM boards and FPGAs.
Independent verifiers on different hardware reach the same verdict from the same receipt, without sharing prompts or answers.
INVAR is free and open source. For evaluation pilots, licensing of the arithmetic, or the FPGA and silicon roadmap, talk to us.