AT0M — a System One Decision AI that runs locally

Pienomial

8 min read Original article ↗
AT0M Pienomial

// a decision model you own, not an API you rent · v0 to evaluate, v1 to deploy

Give it a state and a set of questions — choice, score, or yes-no. It returns one probability per option, in a single forward pass.

No tokens and no free text, so it cannot answer outside your candidate set. It runs as a single local executable, which keeps inference inside your perimeter.

Try AT0M Explore the evidence

45% 50% 55% 60% 65% 70% 75% 80% 85% $0.000001 $0.00001 $0.0001 $0.001 $0.01 $0.10 cost per workflow of five decisions, USD (log scale) accuracy on typed-decisions AT0M Jev others, as a workflow others, prompted terra sol opus 5 Jev · 74.0% 82.1%

↔ swipe the chart

82.1%

typed-decisions, 2,000 decisions

3.6%

calibration error, nothing fitted

Accuracy against what a decision costs. A workflow is five typed decisions about one record. Competitor accuracies and prices are as published; ours is measured over all 2,000 test decisions and priced from a laptop’s measured throughput plus its amortised system cost. The full basis is in the report.

WorkflowEvals — accuracy on all 13,105 question instances. Long records, many typed questions each: the shape the product is actually for. Competitor figures are the published ones. Yes/no questions dominate this set and most answers are false, so accuracy alone flatters everyone here; AT0M’s balanced yes/no accuracy across the four workflows is 71 / 76 / 65 / 81.

deterministic choice · score · noul bounded output calibrated, no temp fitting single Rust binary · CPU / Metal / CUDA runs in your perimeter

// 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.

Evaluate firstv1 · hosted

One POST carries a record and as many questions as you like, answered together in the same pass. No SDK, no client library. Currently an evaluation build; the release will improve on it.

POST /decide/v1 — evaluation endpoint

$ curl -s -X POST \ https://at0m.pienomial.com/decide/v1 \ -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=1.000) → urgent: true (p=0.892)

To be releasedv1

Run a file of decisions, or serve the same API on your own machine. Self-hosted end to end — this is what a production deployment looks like.

./at0m — your machine, your perimeter

$ ./at0m decide --in decisions.json $ ./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: 3.6% ECE on typed-decisions, measured with no temperature fitted anywhere. 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.

Verify the benchmark yourself.

Every figure on this page came from a public test split scored through this endpoint. Point the same benchmark at it and check. One POST carries a record and as many questions as you like, all answered in the same pass — no SDK, no client library.

$ curl -s -X POST https://at0m.pienomial.com/decide/v1 \ -H 'Content-Type: application/json' \ -d '{ "state": "Charged twice for the same card payment this morning.", "questions": { "queue": {"type":"choice", "instructions":"Which team should handle this?", "criteria": {"billing":"invoices, charges, refunds", "technical":"outages, bugs, deploys", "fraud":"unauthorised or suspicious activity"}}, "urgent": {"type":"noul", "instructions":"Needs action today."}}, "email_id": "you@example.com"}' → pick: billing (p=0.998) urgent: noul 0.990

// 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.

Full technical comparison: AT0M · Jev · Laya — collapsed by default ▸

[S1] Pienomial test report — AT0M results, measured by us against the public endpoint and reproducible by anyone: the same script run against the same endpoint returns the same figures.   [L1/L2] Convai Laya model cards — vendor-reported; specialist and routed results kept distinct.   [I1] DecisionEval — independent Jev 1.13.0 rerun on a frozen test.   [J1/J2] TypeSafe documentation — product spec, subject to change.   [B1] Public typed-decisions leaderboard.

A1 · Architecture & interface

A2 · Accuracy & benchmark quality

A3 · Calibration & reliability

A4 · Inference & throughput

A5 · Enterprise ownership

A6 · Economics

Sources: [S1] Pienomial AT0M benchmark report v1.0, 27 Sep 2026 · [L1/L2] Convai Laya model cards · [I1] DecisionEval Jev 1.13.0 independent rerun, 20 Sep 2026 · [J1/J2] TypeSafe documentation · [B1] public typed-decisions leaderboard. Latencies are not hardware- or network-normalized; pricing and availability may change after the report date. "Not disclosed" means the cited sources don't establish the item — not that it's unavailable.