Pienomial Shunyam Typed Decisions
// one forward pass · one probability per option · no text generated

Decisions your laptop can make, and train.

Shunyam scores every candidate answer in a single pass instead of generating one. It reaches 79.3% on the public typed-decisions benchmark — ahead of TypeSafe Jev (72.7%) and Laya (76.6%) — at 16 ms a decision, with probabilities calibrated well enough to gate automation on. Training it on ten thousand of your own records takes about two hours on a laptop.

79.3%
typed-decisions, all question types
2,000 decisions · 400 states
5.3%
calibration error, no temperature fitted
vs 8.1% Laya · 24.6% Jev
16 ms
per decision on a single NVIDIA T4
82 ms for a five-question record
2 hours
to train on 10,000 of your own records
on a laptop · no GPU rented
// measured, not quoted

Every figure here comes from a benchmark's own test split.

Scored end to end through the shipped executable over HTTP. One configuration throughout — no per-dataset thresholds, no prompt tweaks, no temperature fitted anywhere.

Accuracy against cost per workflow: Shunyam at 79.3% for $0.00038, above and far left of every frontier alternative.
Accuracy against cost on the typed-decisions benchmark. Diamonds run a frontier model through a multi-step workflow, circles prompt it once. We are plotted at Jev's cost, since ours has not been measured on comparable hardware and we would rather claim only what was measured.
BenchmarkShunyamLayaJevMeasurement condition
typed-decisions (2,000) 0.7930.7660.727 competitor figures as reported in the Laya write-up
calibration error (ECE) 0.0530.081*0.246 *Laya after fitting a temperature; Shunyam fits none
DAIR Emotion 0.9150.5950.480 described labels; the largest margin on the board
AG News 0.8960.9500.910 described labels; a comparison we trail
Banking77 (77 intents) 0.7910.4250.870 Jev's strongest; a single-task classifier would beat all three

Competitor figures are as reported in the Laya write-up; the three systems were not run through one harness. The typed-decisions labels agree with themselves only 64.6% of the time and the benchmark publishes a teacher self-agreement ceiling of 73.5%, so every score above that — ours included — is fitting label noise as much as signal.

Also measured

Enron spam 0.956 · phishing, never trained on, 0.849 · CLINC150 with out-of-scope rejection 0.758 · a toxicity guardrail that catches three in four harmful requests where answering “no” to everything catches none.

Beyond the trained workflows

On DecisionBench — 43 tasks, 28 domains, none of them trained on — Shunyam reaches 0.520 supported accuracy against 0.419 for a Laya trained on the same typed-decisions corpus. A 10-point margin on data neither has seen.

Label wording matters

Describing each option in a few words rather than naming it is worth 10.9 points on AG News. Pass prose descriptions, not bare enum keys — the model reads what an option means.

One configuration, every benchmark. The same weights answer all of the public test sets above. A specialist trained on any single corpus would beat the corresponding figure; none of them can answer any of the others.
// capability 01 — typed decisions

Three primitives. One pass. A probability on every answer.

A request is a record and one or more questions about it. Nothing is generated, so an answer outside the candidates you supply is impossible by construction.

choice

A set of options, each with a short description. Returns the chosen key and a probability for every option.

score

An ordered list of levels, lowest first. Returns the most likely level and the expected level. Within one level of the answer 97.8% of the time.

noul

A statement that is true or false of the record. Returns the probability it holds — the strongest of the three at 0.873.

POST /decide/v1
→ curl -s -X POST https://shunyam.pienomial.com/decide/v1 \ -H 'Content-Type: application/json' \ -d '{"state": "Our production API has been down since 6 AM.", "questions": {"queue": {"type":"choice", ...}, "urgent": {"type":"noul", "instructions":"Needs action today."}}, "email_id": "you@example.com"}' | python3 -m json.tool "queue": {"choice": "infrastructure", "confidence": 0.999} "urgent": {"noul": 0.892} "ms": 10.5 # two questions, one pass

A five-question record takes 82 ms of server time, about 16 ms a decision; a single-question request takes 26 ms. Requests arriving together are scored in one pass, and a lone request is never delayed.

// how it works

No text is generated. That is the whole trick.

A generative model writes an answer and you hope it stays inside the rules. Shunyam scores the candidates you gave it and returns a distribution over exactly those. Cost grows with the number of options, not with the number of answers considered.

one pass
state + question + candidates └─► single forward pass # all candidates share one pass └─► score per candidate # probabilities from the same pass └─► typed result + probability # choice · score · noul

non-generative

Scores every supplied candidate in one pass. An answer outside the list is impossible by construction, and the probability comes from the same pass — not a second scoring step.

one executable

A single self-contained binary with no Python at inference. Runs from the command line, a JSON file, or as an HTTP server — on CPU, Apple Metal or CUDA.

calibrated by design

Probabilities are meaningful without post-hoc temperature fitting. Enron spam 3.1% ECE, yes/no statements 2.4% — good enough to gate automation on directly.

trainable in place

One script turns your labelled decisions — resolved tickets, approved invoices, triaged alerts — into a model the executable loads. Reference-score checked on export, so a bad build cannot reach production quietly.

// capability 02 — grounded generation over your corpus

A separate build that answers only from your knowledge, offline.

This is a different system from the decision model above, built on the same principle: everything in one file, nothing leaving the machine. A domain corpus is embedded directly into the binary and the model answers strictly from it. We handed one to Claude — an oncology knowledge base in a single 574 MB executable — and asked it to try to break the offline claim.

  • 29/29Every domain question answered correctly, grounded in the embedded corpus — APC in FAP, BRCA in hereditary breast cancer, the Philadelphia chromosome in CML.
  • 0Zero network. lsof showed no TCP, no UDP, no DNS. Three file descriptors, all local.
  • 574 MBSelf-contained. Model weights, tokenizer and the whole corpus in one binary. No external dependencies, no disk reads at inference.
  • =Deterministic. Identical character for character on a re-run — greedy decoding, fixed weights, no sampling.
claude verifying shunyam — offline
→ du -hs shunyam 574M shunyam # model + embedded corpus, one file → lsof -p $(pgrep shunyam) cwd, txt, txt // zero sockets · no TCP/UDP · no DNS → ./shunyam --question "which gene is mutated in FAP?" APC — a tumour-suppressor gene; its loss drives adenomatous polyps in the colon… Results: 29/29 answered — re-ran identical, deterministic.
// why local matters

A capability you own, not one you rent by the token.

Privacy by construction

A model that never phones home cannot leak your queries, your patients' symptoms or your legal questions. The airgap is verified, not promised.

Resilience

Works during outages, on isolated networks, in places with no connectivity at all. Decisions that do not depend on someone else's infrastructure staying up.

Permanence

No vendor can deprecate it, reprice it or change its behaviour. The binary you have today answers identically in ten years.

// make it yours

Bring your labelled decisions. Leave with a model.

The benchmark numbers above are a general model. The point of the design is that a model for your decisions is cheap to make: ten thousand of your own records, five questions each, is about two hours on a laptop. No datacentre GPU, no cluster time, no queue.

  • 01Export what you already decided. Resolved tickets, approved invoices, triaged alerts — a record and the answers a person gave.
  • 02Declare the questions. Each one a choice, a score or a true/false statement, with the options written out in plain words.
  • 03Run one script. It writes out the model the executable loads, plus accuracy and calibration for every test set you supplied.
  • 04Check and serve. The export is scored against reference decisions before it can run, so a bad build cannot reach production quietly.
one record of your training data
{ "state": "{tier: enterprise, thread: [...]}", "questions": { "action": # choice {"refund": "Money back is owed.", "escalate": "A human must decide."}, "urgency": # score, lowest first ["Can wait.", "This week.", "Today."], "needs_human": # true or false "A human must take over." }, "gold": {"action": "escalate", "urgency": "2", "needs_human": "true"} }
If several people labelled the same record, give the spread rather than a single answer and the model learns it. That is where the calibration comes from — the probabilities carry your reviewers' genuine disagreement instead of hiding it.

Try it. 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://shunyam.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 and refunds", "technical": "outages, bugs and deploys", "fraud": "unauthorised or suspicious activity"}}, "urgent": {"type": "noul", "instructions": "This needs action today."} }, "email_id": "you@example.com" }' | python3 -m json.tool