NOMA · OPEN DECISION MODEL

Decisions in milliseconds.

Noma is an open-weight decision model for AI agents and pipelines. It reads a state and a few typed questions and returns a probability for every option, a separate abstain signal, and a measure of its own uncertainty. It never generates text.

MEASURED

Fast,calibrated,andcheaptorun.

16 msMedian per decision

End to end over HTTP on one H100, one question per request.

$0.023Per 1,000 decisions

JevBench method. $0.026 self-hosted on the measured H100.

100%JevBench easy

48 of 48. 98.6% on the original tier (71 of 72).

82.6%Sealed set

386 human-reviewed decisions across 12 families, never used in training.

0.011Calibration error

Easy tier. 0.042 on the sealed set.

18 / 32Layers used

Full depth and a 9B backbone were no more accurate.

WHERE IT FITS

Thedecisionlayerofanagent.

01

Route

Which queue, which model tier, does this need tools or a person.

02

Verify

Did the last step succeed, is the next action safe, is the task done.

03

Decide

Classify, score and check, with a probability for every option.

Noma routes requests before an agent runs and verifies each step after
EVIDENCE

Everynumber,withhowitwasmeasured.

Median latency per decision: Noma 16 ms, decider-4b v2 17 ms, Cygnet 35 ms, NInfer Flash-Next 79 ms, JevOne 87 ms, Nimble 9B 389 ms, OpenJev 463 ms, Jev 1.13.0 652 ms
Cost per 1,000 decisions: decider-4b v2 $0.020, Noma $0.023, Cygnet $0.037, Jev 1.13.0 $0.040, Nimble 9B $0.166
Accuracy: 100% on JevBench easy, 98.6% on JevBench original, 82.6% on the sealed set
Ablations: depth and size, training set size, and targeted multi-step data

Noma's figures are our own measurements with the JevBench client and have not yet been submitted to the leaderboard. Other systems' figures are the published leaderboard values. The full evaluation, including the multi-step reasoning tier, is in the repository.

HOW IT WORKS

Oneforwardpass,nodecoding.

Request, fact channel, cut backbone, decision heads, answer
A decision head on a measured cut

Listwise option scoring on the first 18 of 32 backbone layers. Abstain is its own calibrated output, and four bootstrap-trained heads give an uncertainty estimate from one backbone pass.

Fast serving for a hybrid backbone

The state is processed once and its cache, including linear-attention recurrent state, is forked across questions. Length buckets and CUDA graphs take model time from about 2.3 s to 14 ms.

A fact channel

Deterministic preprocessing turns dates, durations, running totals and thresholds into short fact lines. They are hints to the model, never overrides.

Blind, agreement-gated labelling

Two different frontier models label each item blind; a third judges only their disagreements and a random audit sample.

Decision head: hidden states at marked positions feed four listwise scorers; their mean is the answer and their disagreement is the uncertainty
USE IT

Onefile,onecommand.

pip install blackdrome-noma
noma serve        # API on /v1/systemone, playground on /

from noma import Noma

model = Noma.from_pretrained("BlackdromeAILabs/noma")
answers, _ = model.decide(
    state="Deploy 4/6 finished. 3 of 12 pods failing readiness.",
    questions={
        "step_ok": {"type": "noul", "instructions": "Did the rollout succeed?"},
    },
)

The weights are one 5.4 GB file with the backbone and adapter already merged. It runs in 5.2 GB of GPU memory and speaks the same /v1/systemone API as Jev, so existing clients work unchanged.

A local playground ships with the server: paste a state, build questions, and copy the request as code.

The Noma playground answering two questions about a contract clause
COMPARED

Anopen-sourcealternativetoJev.

Noma does the same job as Jev, speaks the same /v1/systemone API, and runs on your own GPU. It is faster and cheaper on single-pass decisions; Jev is stronger on multi-step reasoning. Read the full comparison →

Noma compared with Jev and other decision models on JevBench
ModelWeightsHow you run itEasyStandardHardMedian latencyCost per 1,000
NomaBlackdrome AI LabsOpen, MPL-2.0Self-hosted, one 5.4 GB file100%98.6%51.4%16 ms$0.023
Jev 1.13.0TypeSafeClosedHosted API100%99.0%74.1%652 ms$0.040
OpenJev (thinking)CommunityOpenSelf-hosted, 26B MoE100%100%78.2%463 msnot listed
Nimble 9BCommunityOpenSelf-hosted, Qwen3.5-9B100%94.8%65.5%389 ms$0.166
CygnetCommunitySee leaderboardFrozen Gemma-4-12B100%96.9%75.5%35 ms$0.037
decider-4b v2CommunitySee leaderboard4B model100%96.9%67.3%17 ms$0.020

Noma's figures are our own runs with the JevBench client on one H100 and are awaiting independent measurement. Other systems' figures are published JevBench leaderboard values as of September 2026. Noma's hard-tier figure covers the 111 public items; on a held-out half it scores 46.4%. Hosted latencies include a network round trip; Noma's was measured on the same machine as the server.

QUESTIONS

WhatpeopleaskaboutNoma.

Is Noma an open-source alternative to Jev?
Yes. Noma is an open-weight decision model released under MPL-2.0 that does the same job as Jev: it reads a state and typed questions and returns a probability for every option without generating text. You download the weights and run it on your own GPU, so there is no per-call fee and no data leaves your infrastructure.
Does Noma work with existing Jev clients?
Yes. Noma serves the same /v1/systemone wire format as Jev, so a client written for Jev works by changing the base URL. Noma adds two fields of its own, an abstain probability and an uncertainty estimate, under a separate key that existing clients can ignore.
How fast is Noma compared with Jev?
In our measurements with the JevBench client, Noma answers in 16 ms at the median, end to end over HTTP on one H100, with one question per request. The JevBench leaderboard lists Jev 1.13.0 at 652 ms. Jev's figure includes an internet round trip to a hosted API, while Noma's was measured on the same machine as the server.
How accurate is Noma compared with Jev?
On everyday single-pass decisions the two are close: Noma scores 100% on JevBench easy and 98.6% on the original tier, against 100% and 99.0% for Jev 1.13.0. On the hard tier, which needs multi-step reasoning, Jev is clearly stronger: 74.1% against 51.4% for Noma. If your questions need chained arithmetic or date reasoning, use Jev or a reasoning model for those.
What does it cost to run Noma?
By JevBench's method, which multiplies input tokens by the hosted price for the model's size class, Noma costs $0.023 per 1,000 decisions, against $0.040 for Jev 1.13.0. Self-hosted on the H100 we measured on, one serial stream costs about $0.026 per 1,000 decisions. The weights are free.
What hardware does Noma need?
An NVIDIA GPU with 6 GB of memory or more. The weights are one 5.4 GB file and use about 5.2 GB of GPU memory. The published latencies are from a Linux machine with an H100 and the fast path enabled; it also runs on Apple silicon and CPU, more slowly.
How do I install Noma?
Run pip install blackdrome-noma, then noma serve. That downloads the weights from Hugging Face, starts the API on /v1/systemone, and opens a local playground.
What is Noma not good at?
Multi-step reasoning. Noma answers in a single forward pass with no scratchpad, so questions that chain several calculation steps, or trace a long policy through its amendments, are outside its scope. It is also text only, limited to 4,096-token states, and evaluated in English.
SCOPE

Builtforsingle-passdecisions.

Noma classifies, routes, scores and verifies. Questions that need several chained steps of arithmetic or date reasoning belong with a reasoning model, and Noma's abstain and uncertainty signals are there to hand them off. Text only, states up to 4,096 tokens, evaluated in English. Open weights under MPL-2.0.