AT0M: a private, System One Decision AI that runs locally.

// how you deploy it

The executable is the product.

AT0M will ship as a single self-contained Rust binary — no Python at inference, no service in the path, nothing to rent. That is the deployment, and it will be the only thing that ends up in your perimeter. The hosted endpoint exists for one reason: so you can check every number on this page before you download anything.

POST /decide/v0 — evaluation endpoint$ curl -s -X POST \
  https://at0m.pienomial.com/decide/v0 \
  -H 'Content-Type: application/json' \
  -d '{"state": "Our production API has
       been down since 6 AM.",
       "questions": {
         "queue": {"type":"choice",
                   "criteria": {...}},
         "urgent": {"type":"noul",
                    "instructions":"Needs action
                     today."}}}'
→ queue: infrastructure (p=0.999)
→ urgent: true (p=0.892)

./at0m — your machine, your perimeter# score a file of decisions, no server
$ ./at0m decide --in decisions.json

# or serve the same API yourself
$ ./at0m serve --port 8080 --device metal
listening on :8080 · metal · 54 dec/s
$ curl -s localhost:8080/decide \
    -d @decisions.json

→ no network, no provider, no per-decision fee

v0 is the evaluation endpoint; v1 is the executable release — the hosted service is a way to try the model, not a way to run it. Every figure on this page was measured against v0, the evaluation build, so they are the floor rather than the ceiling: v1 is expected to be more accurate, and we will republish every number on this page when it ships.

// how it works

What the model actually does.

• Non-generative.It scores your supplied options, it doesn't write text. The output is a probability per option — so a malformed or out-of-list answer is structurally impossible, not just discouraged.
• Calibrated by construction.Probabilities mean what they say without post-hoc temperature fitting: 5.6% ECE on typed-decisions, 3.7% on its choices, 3.7% on Enron spam. Set an escalation threshold, auto-act above it, route the rest to a human.
• Local inference.Runs as a standalone Rust binary on CPU, Apple Metal or CUDA. Inference stays in your perimeter — no required third-party API in the path, so no per-decision network round-trip.
• Trainable on your own decisions.Ten thousand of your own records, five questions each, is about two hours on a laptop. No datacentre GPU, no cluster time.

// the numbers, with their measurement conditions

Benchmark results.

One configuration across every public test set — no per-dataset tuning or prompt tweaks. 38,862 decisions, scored in one sweep.

Two things we'd flag before you read the numbers. The public typed-decisions benchmark's labels are noisy — they self-agree ~65% of the time against a ~73% teacher-model ceiling — so we don't read small margins near the top as meaningful, ours included. And every AT0M figure here came from a single sweep through one harness, while the competitor figures come from their own write-ups under their own conditions — so read the table as "each number with its source," not a single scoreboard.

Laya figures, and Jev's on the classification sets, are as reported in the Laya write-up. Jev's typed-decisions figure is DecisionEval's independent rerun. On calibration, TypeSafe publishes no figure at all, so Jev's range is assembled from four independent studies, none temperature-fitted.

// what we'd actually defend

The parts that don't depend on the benchmark.

The accuracy number is near the top but sits inside admitted label noise, so we don't hang the pitch on it. The claims we'd stand behind under scrutiny are architectural:

• Bounded output — can't answer off your candidate set. (A generative model can; that's the failure mode this design removes.)
• Calibration without temperature fitting — thresholds you can trust straight out of the model.
• Local inference — the model is an artifact you run in your perimeter, not an API you rent, and there's no per-decision round-trip.
• Cost structure, not a discount — nothing is generated, so there are no output tokens to pay for. The marginal cost of the next decision is electricity.
• Deterministic — send the same request twice and you get the same probabilities, to the last digit. Two full re-runs of every set on this page, 38,862 decisions each, came back identical on every metric: accuracy, calibration error, mean confidence, F1. The headline survives load as well — typed-decisions scores 0.7885 whether you send it one request at a time or five hundred at once. The one thing that moves is the split underneath that total: batched beside different neighbours, an item sitting on a decision boundary can land the other way, so per-primitive figures wander by a decision or two in 2,000 while the total holds. Re-run it and you get our numbers.
• Reproducibility — the endpoint that produced these numbers is the same one you can point your own eval at.

And the parts we wouldn't: it compares a value to a threshold well, but not one field of a record against another, so compute those predicates in code. Calibration decays off-distribution — 0.037 on spam it has seen, 0.171 on phishing it hasn't. Both are measured below.

// for engineers & procurement

The full evidence, when you want it.

A comparative evidence inventory across AT0M, Jev 1.13.0 and Laya, carried from the technical paper. It is not a harmonized three-model benchmark: figures were obtained under different conditions, and each is tagged with its source and how it was measured.