Triaxis Atum -- Deterministic AI Suite

One kernel. 18 ways to put deterministic AI to work.

Atum is a toolkit for building AI that behaves the same way every time you run it -- not a chatbot, and not only for compliance teams. Use it wherever repeatable, explainable results matter.

Six compete head-to-head with stochastic AI. Twelve more are kernel-native capabilities with no mainstream machine learning equivalent.

Fraud and risk scoringForecasting and simulationIndustrial and scientific modelsAuditable decisions when you need them

Explore the Modalities Download Technical Paper

The Sheffer kernel

6 compete with conventional AI / 12 kernel-native only

Neural Networks

Symbolic Regression

Reinforcement Learning

Neuro-Symbolic

Generative Models

Bayesian Optimization

Compositional Programming

Verifiable Inference

Dynamical Inference

Rigorous Enclosure

Exact Expectation

Behavioral Equivalence

Exact Inversion

Distribution Fingerprints

Conformal Prediction

Spectral Engine

Atum Tensor

ASM Shadows

Modalities on one kernel

Trainable kernel parameter

0.0

Max Py/Rust inference delta

Violations in 10M enclosure probes

The kernel story

A simple analogy for why one shared mathematical idea can power so many different tools.

The circle

One famous constant works for every perfect circle. Same number, any size.

The oval

Stretch the circle and pi alone is not enough. You need extra math tuned to that specific shape.

Sheffer kernel

Your data

One shared primitive for Atum -- tuned to the dataset or problem you are solving, like oval math tuned to the oval.

Most of us first meet pi in school: a single number that unlocks every calculation about a circle. It is a discovery that feels fundamental -- one idea that keeps showing up because circles are everywhere.

Now picture an oval. It is close to a circle, but not the same shape. If you try to measure it using circle formulas alone, you will be wrong. You need a family of calculations that respect the oval's particular stretch and curve. The underlying geometry is familiar; the numbers depend on the shape in front of you.

Atum is built on a similar insight for AI. Deep inside every Atum tool is the same mathematical building block -- the Sheffer kernel. Like pi for circles, it is a shared primitive we can reuse across many kinds of work. Like measuring an oval, it still has to be tuned to your data: a small set of parameters is adjusted so the kernel fits the problem -- fraud detection, process control, scientific modeling, or any other task you point it at.

That tuning is not a weakness. It is how one kernel becomes 18 different capabilities without rebuilding the foundation each time. 6 of them go head-to-head with conventional AI tools. 12 do things that only make sense when the math is deterministic from the ground up.

The practical payoff: models that give you the same answer on rerun, outputs you can trace step by step, and -- when your situation calls for it -- evidence you can hand to a customer, a partner, or an auditor. Auditability is one use case, not the only one.

The 6

Direct successors to established stochastic approaches. Benchmarked head-to-head -- and competitive or stronger on matched runs.

Neural Networks

97.78% MNIST accuracy

vs. ReLU 96.89%, GELU 97.03%, Swish 96.69%

Symbolic Regression

43W/31T/26L vs PySR on 100 AI Feynman equations

PySR 1.5.10, matched wall-clock

Reinforcement Learning

7/8 episodes stabilized, mean return -16.50

vs. LQR: 3/8, -24.71 -- 21-parameter policy

Neuro-Symbolic Execution

Heating R2 0.9963, Cooling R2 0.9944, Concrete R2 0.8777

vs. Ridge: 0.9335 / 0.9313 / 0.4342

Generative Models

5/5 UCI datasets beat RealNVP; 1,064/1,064 bit-exact Python/Rust

72,102-79,051 samples/sec at batch 1024 on a two-gen-old GPU

Bayesian Optimization

6W/7L full suite; 11.5x lower regret on constrained Rosenbrock

5-20x faster than scikit-optimize, CPU only

Only possible on the Sheffer kernel

The 12 kernel-native modalities

These capabilities exploit input-space, data-space, and representation properties of the kernel that stochastic primitives cannot carry. Most have no mainstream machine learning equivalent.

Weight-space algebra

Compositional Programming

Trained networks as math objects: add, subtract, SHA-256 commit, combine with Boolean logic. No stochastic equivalent.

Max delta ~7.5e-7 on 1,000 probes -- float32 ULP limit

Deep-dive

Cryptographic audit

Verifiable Inference

Every decision ships with a 128-byte proof. Bit-exact Python/Rust forward pass with Groth16 verification.

0.0 max delta Python/Rust -- 2.7ms verify -- ~250 proofs/sec

Deep-dive

Dynamical systems

Compositional Dynamical Inference

35-parameter formulas for complex systems with a zero-knowledge audit package. Not a Neural ODE approximation.

NRMSE 0.048 at N=64 -- Neural ODE never breaks 0.05 within N=512

Deep-dive

Input-space bounds

Rigorous Enclosure Engine

Guaranteed output bounds over input boxes for committed Sheffer models -- theorems, not Monte Carlo samples.

0 violations in 1e7 probes -- byte-deterministic certificates

Deterministic UQ

Exact Expectation Engine

Exact means, variances, and Sobol indices for shallow Sheffer models. Monte Carlo replaced by closed-form quadrature.

2056-3349x speedup vs MC -- Sobol agrees with SALib within tolerance

Function identity

Behavioral Equivalence

Canonical normal form where equal bytes mean equal functions -- court-grade model forensics and deduplication.

200k rewrite variants, 0 mismatches -- 100k ULP-tamper pairs, 0 collisions

Certified recourse

Exact Inversion

Run committed Sheffer kernels backwards: exact preimages, interval clamp regions, and provably minimal counterfactuals.

Round-trip worst 3.04e-10 on 1e6 probes -- ReLU preimage is NP-hard

Data-space drift

Distribution Fingerprints

Deterministic drift detection on any tabular data via committed kernel mean embeddings -- not limited to Sheffer models.

Power 0.367 vs RBF-MMD 0.316 -- byte-identical across rebuilds

Calibrated intervals

Conformal Prediction

Distribution-free prediction intervals around any deterministic Atum point predictor -- no posterior sampling.

Coverage within +/- 1% at three levels -- committed calibrator artifact

Ordered signals

Deterministic Spectral Engine

Hash-committed spectral features for time-series and waveform data -- cyber, clinical, and industrial signal paths.

ECG AFib test AUC 0.8637 -- byte-stable bundle hashes across runs

High-dimensional regression

Atum Tensor

Sheffer-native tensor train with rank-cliff hardening and hash commitment -- mixed-alpha CompProg composition.

14/16 task cells at R2 >= 0.99 -- 16/16 clear R2 >= 0.85

Deterministic distillation

ASM (Algebraic Shadow Models)

Distill any stochastic model into a committed CPU shadow with an empirical disagreement bound over a declared envelope.

98.21% true-label retention at 40.11% parameter count

Full benchmark reference for all 18 modalities

A deeper dive

Two flagship kernel-native capabilities with no mainstream equivalent -- compositional algebra over trained models, and cryptographic receipts for every inference. Use them separately or together when you need decisions you can operate on and prove.

Compositional Programming

Trained neural networks as first-class mathematical objects. Add them. Subtract them. Commit them with SHA-256. Combine a learned risk score and a compliance rule in a single auditable file. A quarterly model update ships as a reviewable algebraic delta -- not a full retrain. This has no prior art.

Why this matters

In stochastic deep learning, a model is a black box. Updating it means retraining, and explaining it means approximating after the fact. Compositional Programming changes the unit of work: a trained model is no longer an opaque artifact -- it's an algebraic object you can operate on directly.

Add two models and the result is exact, not an ensemble approximation. Subtract a prior version from a new one and the residual is the entire audit trail -- a precise, reviewable description of what changed and by how much. Commit any object with SHA-256 and its provenance becomes part of the mathematics, not a separate log file.

Residuals on Boolean composition (AND/OR/XOR/NAND/NOR) measure ~1e-7 at corners -- the float32 noise floor. Additive composition shows a max delta of ~7.5e-7 across 1,000 probes -- the float32 ULP limit. The algebra is exact to the precision of the hardware.

Verifiable Inference

Every model decision ships with a 128-byte cryptographic receipt. An auditor's full review of 10,000 decisions completes in under 40 seconds. Full-portfolio audit replay becomes cheaper than the statistical sampling it replaces.

128 Bytes

Cryptographic proof size

2.7ms

Proof verification time

0.0

Max delta, Python/Rust, 10,000 inputs

~250/sec

Audit throughput (proofs per second)

How it works

Each inference produces a compact cryptographic receipt -- 128 bytes -- that ties the exact input, the exact kernel state, and the exact output together. An auditor (or an automated system) replays the receipt and confirms, in 2.7 milliseconds, that the decision is genuine and untampered.

Because the kernel is deterministic, replay produces a bit-identical result every time. Across 10,000 test inputs run through both the Python reference implementation and the Rust production implementation, the maximum delta measured is 0.0 -- zero drift, by construction, not by tolerance band.

At roughly 250 proofs per second, full-portfolio audit replay -- checking every decision a model has ever made -- becomes cheaper than the statistical sampling programs it replaces. Pair it with Compositional Programming above and you can verify both a model's output and the algebraic delta that produced its successor.

Practical Boundaries

Atum is built for work where you need the same answer every time, outputs you can trace, and -- when it matters -- evidence you can defend. That is a different problem than consumer recommendation feeds, open-ended content generation, or large-scale general-purpose language and image models.

For those use cases, stochastic deep learning is still the right tool, and we do not claim Atum offers an advantage there.

Our portfolio is aimed at production scoring, modeling, simulation, and decision systems where repeatability, composability, and verifiable outputs carry real weight -- whether the driver is internal quality, customer trust, or regulatory review.

Triaxis GDI · The Companion

Build deterministic with Atum. Measure anomalies with GDI.

GDI finds known and unknown anomalies in vector data -- including embeddings from Atum models in production. Geometric measurement, no GPU, no domain-specific models to rebuild.

See GDI Platform