AEFINITY AI INC.

AI inference you can check, not just trust.

We build CIS-2: an open specification and verifier for bit-exact fp32 transformer inference. The same pinned model and the same input produce the same bits on every conforming machine, and anyone can reproduce that claim on their own hardware in under fifteen minutes.

CIS-2 on GitHub Conformance dataset Paid pilots

What it is not: CIS-2 does not show that a model's answer is correct, safe or fair. It covers fp32 greedy decoding on small open models, mostly on CPU; production bf16/GPU serving is outside the spec today. No unaffiliated party has reproduced it yet; every run on this page was done by us.

What we build

CIS-2 specification and verifier

A written specification of canonical floating-point semantics for fp32 transformer inference, with two clean-room implementations (C and Rust, written by isolated AI coding agents run by one operator) that produce identical digests from the specification text alone.

Conformance evidence

Pinned test vectors, expected digests and machine fingerprints, published so a third party can re-run the checks and compare against the record rather than against our word.

Inference receipts and continuous validation

A receipt binds an output to a pinned model, an input and a verifiable digest. Continuous validation turns one-shot checks into an ongoing integrity monitor; in our one experiment the verifier's pinned artifact-hash check stopped a run on a weight file with one corrupted byte.

Verifiable inference and agent receipts are an active field with many good projects in it, for example Gensyn's REE and Prime Intellect's TOPLOC. We make no priority claim. CIS-2 is a written, open specification with independently implemented verifiers, so a third party can replay a run on its own hardware. The repository also holds a design note for a prototype receipt-gated tool gateway for agents (the prototype code is not in this repository); it was tested against hand-constructed attacks only.

Reproduce it yourself

No account, no token and no GPU are needed. The full self-check builds the Rust reference and the C verifier and runs nine or ten checks against the repository's own pinned digests. It needs git, curl, gcc, make, objdump and a Rust toolchain, and downloads the pinned weights from Hugging Face:

git clone https://github.com/Aefinity-AI/cis2-spec && cd cis2-spec && ./selfcheck.sh

A shorter path checks the four pinned digests with the C verifier only and needs no Rust toolchain:

git clone https://github.com/Aefinity-AI/cis2-spec && cd cis2-spec && scripts/self_check.sh

Both paths end with a PASS or FAIL line against the pinned HuggingFaceTB/SmolLM2-135M test vector. If your machine produces a different digest, that is a finding we want to hear about.

Evidence

The same pinned digests have been reproduced on several different classes of machine, all run by us:

ClassExamples
x86-64 with AVX2 and FMAIntel Core i5 laptops and desktops
x86-64 scalar, no AVX2 or FMAIntel Celeron N4020 and N4020C
aarch64 phone (Android)Samsung Android phone; see section 6 of the cross-ISA note
Emulated CPUQEMU (aarch64 user-mode)
NVIDIA GPUs, fp32 pathTesla T4 and P100 on Kaggle, host and CUDA digests equal (the CUDA code is not in the repository)

Results we publish include the negative ones. Grouped and int8 GPU kernels do not match the fp32 digests, by design, and the record says so.

Concrete integrity demonstrations (these show why full-logit digests matter more than matching the final text alone):

A related research manuscript is under confidential peer review. Venue and submission details are not listed publicly during double-blind review. See the Paper Status page for citation guidance and preprint status.

Why it matters

Most claims about an AI system's behaviour rest on trust in the operator. For fp32 runs of the supported small models, bit-exact replay turns one specific claim, "this output came from this model on this input", into something a customer or an auditor can check on their own machine. We think this is relevant to record-keeping and traceability requirements; no auditor or lawyer has confirmed that mapping. A tolerance-based comparison cannot show that the exact computation was reproduced; whether you need that is the question a pilot answers.

We are careful about what this does not do. CIS-2 does not make a model correct, safe or fair. It makes the provenance of an output checkable, so that the harder questions can be asked about a fixed, agreed-upon artifact instead of a moving target. For how this fits into the broader AI safety landscape (evaluation reproducibility, monitoring, accountability, high-assurance deployment), see CIS-2 and AI Safety.

One-shot checks are useful; continuous validation is stronger. A completed continuous-validation experiment on ordinary older hardware is published as 2026-09-27 Continuous Validation.

For a short plain-language explanation written for non-experts, see Why Bit-Identical Inference Matters for Trust. A one-page overview is available as the Elevator Summary. A four-step adoption path for design partners is here. All public materials are collected under docs/public.

Work with us: paid pilots

One of your inference pipelines emits CIS-2 receipts, our verifier replays them on a machine separate from yours, and you get a report of every mismatch plus a replayable artifact. 4 to 6 weeks. Paid pilots; contact us for scope and terms. Details and how to start.

Contact

AEFINITY AI INC. is an early-stage company in Orange, Texas, founded by Justin Thompson. We are looking for pilot and design partners who need checkable inference, and for compute partners who want the specification tested on their hardware.