frontier-infra/jebadiah-9b-v0

Jebadiah 9B v0

Jebadiah (Jeb for short) is Frontier Infra's open System One style decision model, trained and served with AINode: it answers typed questions with a probability over the option labels instead of generating text, calibrated per question type when the shipped temperatures are applied. Three question types, the same three Jev uses: choice (pick one of N), noul (a yes or no statement, returned as P(yes)) and score (place the state on an ordered rubric). It is trained with AINode's trainer on public data only and served by AINode's /v1/decide and /v1/systemone routes on any NVIDIA GPU. The routes answer Jev's three question types; the request schema is AINode's own (documented on the route), not Jev's exact wire format.

This repository holds the v0 9B adapter: a LoRA on Qwen/Qwen3.5-9B-Base (pinned revision 68c46c4b), one epoch over 11,072 public training questions, trained on one H100 PCIe in 45 minutes. Its 4B sibling is frontier-infra/jebadiah-4b-v0. v0 is a fixed version. Newer versions are published as new repositories and never replace this one. v1 is out: frontier-infra/jebadiah-9b-v1, with human-rubric training data and the ordinal score fix.

Made in Texas.

Read this first. Served through AINode today, /v1/systemone and /v1/decide return the model's raw distribution; the per-type temperatures in temperatures.json are applied offline in every calibrated number on this card (AINode issue 276 tracks applying them on the route). To reproduce the numbers, or to get the calibrated answer yourself, use the standalone script in scripts/ (below).

Namespace note: published under jbrashear on 2026-09-22 and moved to the frontier-infra organization on 2026-09-23; the old URLs redirect. The version is unchanged.

Results

Measured by us with AINode's bench, one logit read per question, the same rendered prompt for every model. Accuracy is the share of questions whose top label is the human label. Decision Score is Jevals' metric: 100 = perfect, 0 = guessing the label base rates, below 0 = worse than that. These are our numbers on the public suites, not rows on the Jevals board.

Set (questions)	Type	Accuracy	Floor (majority label)	Decision Score (Jevals)	ECE, temperatures applied	Flips over identical repeats
Jevals PubMedQA (300)	noul	89.0	62.0	64.0	0.048	0.0%
Jevals Banking77 (300, 77 options)	choice	71.0	1.3	57.6	0.124	0.3%
Jevals HelpSteer2 helpfulness (300, 5 levels)	score	40.3	41.7	-21.4	0.392 (raw 0.201)	1.0%
Nimble held-out eval (324)	mixed	76.9	17.6	64.2	0.078	0.3%
Kev transfer-v4 test (764)	mixed	83.0	21.5	64.5	0.075	0.0%
Kev decision-v7 test (1,440)	mixed	80.5	20.3	67.6	0.120	n/a
typed-decisions test (2,000)	mixed	79.4	15.3	60.9	0.061	0.2%

Nimble's 13 public human-labelled subsets (3,880 questions), macro accuracy: 75.0 (per subset: aegis2 78.0, boolq 85.3, civil_comments 85.3, helpsteer2 37.3, massive-de-DE 83.7, massive-en-US 85.4, multinli 85.0, paws 81.6, pubmedqa 72.4, squad2 76.6, summeval-consistency 80.6, summeval-relevance 49.2, vitaminc-dev 74.6). For scale, Bespoke's published table puts Nimble-9B at 74.8 and Jev at 76.0 on the same subsets with their scorer, and the untrained 4B base at 65.7 with ours.

Where it is weak: the score type on human rubrics. HelpSteer2 helpfulness and summeval-relevance sit at their floors, and the fitted score temperature (0.39, a sharpening learned from soft teacher targets) makes HelpSteer2's calibration worse rather than better. That is the first thing v1 changes.

Every eval record (per question: option keys, probabilities, pick, label, repeat, option order) is in eval/, with eval/results.json carrying the full metric set (Brier, NLL, ECE raw and fitted, per-question floors, flips with their top-2 gaps) and the resolved training configuration.

How it decides

The temperature fit. temperatures.json holds one temperature per question type (choice 0.90, noul 0.91, score 0.39), fitted by minimising NLL against the hard label on the calibration split (272 records, 504 questions: choice 225, noul 147, score 132); the file records NLL before and after per type. The score temperature (a sharpening) was learned from soft teacher targets and transfers to typed-decisions but not to human rubrics, where it makes calibration worse; v1 changes that. The ECE column in the results table is measured on the evaluation sets with these temperatures applied.

The prompt is AINode's own decide rendering (ainode.api.decide.build_messages, source commit e5c08938, prompt_source_sha256 d2660ebe... in prompt_contract.json), through the base chat template with thinking off. The question's state, instructions and options are rendered as structured text; the option labels are single tokens (68 of them); the model's answer is the distribution over those label tokens at the last prompt position, read in fp32 from the last hidden state and then temperature scaled per type (temperatures.json: choice 0.90, noul 0.91, score 0.39, fitted on a held-out calibration slice of the training pool). Nothing is generated.

The supported way to run it is AINode, which renders the prompt exactly as trained:

curl -sS https://<your-ainode>/v1/systemone -H "Authorization: Bearer <key>" -H "Content-Type: application/json" -d '{
  "model": "frontier-infra/jebadiah-9b-v0",
  "state": {"ticket": "Customer says the invoice total does not match the quote."},
  "questions": {
    "route": {"type": "choice", "instructions": "Which team should take this ticket?", "criteria": {"billing": "an invoice, a charge or a refund", "support": "a product question", "sales": "a quote or a renewal"}},
    "urgent": {"type": "noul", "instructions": "The customer is blocked from working.", "criteria": {"true": "work has stopped", "false": "it can wait"}}
  }
}'

The route takes questions as an object keyed by your id, with type, instructions and criteria (choice and score: name to description; noul: an optional true and false description). Served through AINode at temperature zero with a constrained single token, the picks and the confidences are identical across repeats; the flip rates in the table above come from the local batched logit read, which sees bf16 ties the route does not.

Standalone, reproducible

scripts/ in this repository carries the trainer's own copies of the renderer and the logit read: ainode_prompt_verbatim.py is AINode's decide rendering copied verbatim from getainode/ainode at e5c08938 (its sha256 is the prompt_source_sha256 in prompt_contract.json), jebadiah_prompt.py turns a /v1/systemone question into that prompt with single-token labels, jebadiah_model.py reads the label-token logits at the answer position in fp32, and decide_standalone.py runs one request end to end:

pip install torch transformers==5.17.0 peft==0.21.0 huggingface_hub
huggingface-cli download frontier-infra/jebadiah-9b-v0 --local-dir jeb
python jeb/scripts/decide_standalone.py --base Qwen/Qwen3.5-9B-Base --revision 68c46c4b3498877f3ef123c856ecfde50c39f404 \
  --adapter jeb --request jeb/scripts/example-request.json          # add --no-temperatures for the raw distribution

It prints the answers in the route's shape (choice: choice, confidence, probabilities; noul: noul = P(true); score: score, legend, probabilities) plus the temperatures it applied. Runs on CPU too (slow, minutes per request without the DeltaNet kernels), which is how it was checked before publishing.

Thresholds belong to the caller: act on a high probability, confirm or escalate on a middle one, hand a low one to a person or a bigger model. The model never refuses; policy is built from decisions.

Training

• Objective: cross-entropy over the candidate option-label logits at the answer position, with the source's gold distribution as the target where it provides one (typed-decisions) and the hard label otherwise. No text generation is trained.
• Adapter: LoRA r=16, alpha=32, dropout 0.05 on every linear projection including the Gated DeltaNet projections (in_proj_qkv, in_proj_z, in_proj_a, in_proj_b, out_proj, plus the attention and MLP projections), 43.3M trainable parameters. bf16, SDPA attention, micro-batch 8, learning rate 1e-4, one epoch, 1,384 steps, gradient checkpointing.
• Data (public only): LocalLLaMA/typed-decisions train (Apache-2.0, revision ea930645) and the Kev v7 training sources whose licenses permit derived weights (BoolQ, MNLI, DBpedia14 and Kev's contrastive and composition sets, Kev suites revision a88f56db). 11,072 training records and 272 calibration records (504 calibration questions) after a 95/5 split by question family. Nimble's train set is excluded (no license stated); the Jevals test sources are excluded from training. No private data of any kind.
• Compute: one NVIDIA H100 PCIe 80 GB, 45 min training, 26 min evaluation, torch 2.11, PEFT 0.21.

Limitations

• Single-hop judgments only. A question that hides a chain of inference should be split into hops.
• The score type is not yet trained on human helpfulness rubrics; treat score outputs on such rubrics as uncalibrated until v1.
• AINode caps a choice question at 20 options; Banking77's 77 options were scored with an extended single-token alphabet for the benchmark only.
• English data. Massive's German subset scores well, but nothing else was checked.
• Calibration was fitted on the training distribution. Refit the temperatures on your own data before trusting a threshold.

Versioning and license

v0 is frozen. Later versions land as jebadiah-<size>-v<N> repositories. The adapter is Apache-2.0, the base model is Apache-2.0. Evaluation data: Jevals suite 0.1.0 (CC-BY-4.0, "Jevals (jevals.com), release 2026-09-18"), Nimble public subsets (Bespoke Labs), Kev test sets and typed-decisions test, each under its own license.