Code Models Results Decision Index

MoDe-M

MoDe-M is a sparse mixture-of-experts decision model for text and JSON, built on MobileMoE-M. It returns calibrated answers in one forward pass, without generating tokens.

• Faster and more accurate than d3-nano and Intern-Decision-4B: 17.7 ms vs 40.1 and 55.2 ms median, and 47.10 vs 42.22 and 38.00 on the Decision Index (d3-nano, Intern-Decision-4B). 2.4x faster than GLiDE, and within 1.5 ms of Liquid AI's d1-2B at the median with a 5x lower mean (29.8 vs 159.1 ms).
• Sparse: 0.53B of its 2.82B parameters are active per token, 3.6x fewer than d1-2B (1.92B), 4x fewer than d3-nano (2.21B), 3.5x fewer than GLiDE 2B (1.88B) and 9x fewer than Intern-Decision-4B (4.66B): 4 of 60 routed experts plus one shared expert in each layer.
• Calibrated: probabilities are temperature-scaled per question type, so they work as confidence scores.

Model details

---

The MoDe family has three sizes: MoDe-S, MoDe-M, MoDe-L. All three share the request format, the inference package and the calibration method; larger sizes are more accurate and slower.

Property	Specification
Checkpoint	Decision fine-tune of MobileMoE-M, with an option-scoring head
Parameters	2.82B total, 0.53B active per token
Architecture	Sparse mixture of experts, 26 layers; each layer has 60 routed experts (4 per token, sigmoid router) and one shared expert
Context length	8,192 tokens per forward pass; longer requests are split by question, never truncated
Vocabulary	128,256 tokens
Input	A state (text or JSON) and any number of named questions
Output	A calibrated probability for every option of every question, with no generated tokens
Languages	English
License	FAIR Noncommercial Research License

MoDe-M is designed for any pipeline step that needs a decision: routing and triage, intent and topic classification, moderation, tool selection, and judging. It is not a chat model.

Knowledge-heavy questions and multi-step reasoning favor larger models (see the knowledge score below). It is tested in English and reads text only.

Inference

---

MoDe-M runs with the MoDe package, which loads the weights, prepares the GPU, and reads the answers from one forward pass, so there are no sampling parameters to set.

Quick start:

pip install "MoDe @ git+https://github.com/newrexlabs/MoDe"

from mode_decider import MoDe

model = MoDe.from_pretrained("newrexlabs/MoDe-M")

# Several named questions over one state, answered in one pass
decision = model.decide(
    state={"ticket": "I was charged twice for order #4417. I need the duplicate refunded before my rent is due on Friday.",
           "customer": {"plan": "premium", "orders_last_year": 23}},
    questions={
        "team": {"type": "choice", "instructions": "Which team should handle this ticket?",
                 "criteria": {"billing": "Payments, refunds and invoices", "shipping": "Deliveries and returns",
                              "tech": "App, login and account problems"}},
        "refund": {"type": "noul", "instructions": "Is the customer asking for a refund?"},  # yes/no
        "urgency": {"type": "score", "instructions": "How urgent is this ticket?", "criteria": ["Routine", "Soon", "Today"]},
    },
)

team     billing    ████████████████████████ 0.999  ◀ decision
         shipping   ░░░░░░░░░░░░░░░░░░░░░░░░ 0.001
         tech       ░░░░░░░░░░░░░░░░░░░░░░░░ 0.000

refund   true       ████████████████████████ 0.997  ◀ decision
         false      ░░░░░░░░░░░░░░░░░░░░░░░░ 0.003

urgency  0 Routine  ░░░░░░░░░░░░░░░░░░░░░░░░ 0.020
         1 Soon     ██████████████████░░░░░░ 0.765  ◀ decision
         2 Today    █████░░░░░░░░░░░░░░░░░░░ 0.215

Many requests in one call

tickets = ["Where is my parcel? It was due Monday.", "The app crashes when I open settings."]
team = {"team": {"type": "choice", "criteria": {"billing": "Payments", "shipping": "Deliveries", "tech": "App problems"}}}
for decision in model.decide_batch([{"state": t, "questions": team} for t in tickets]):
    print(max(decision["team"], key=decision["team"].get))

How inference works

1. The request becomes one token sequence: STATE: <state> (a non-string state as compact JSON with sorted keys), then for each question a line [Q<i>|<type>] <instructions> followed by one line per option, (<j>) <option id>: <description>.
2. One causal forward pass through the backbone. On a GPU, a single request of up to 8,192 tokens is replayed from a CUDA graph captured at load.
3. The hidden state is read at the end of each question line and each option line. A small pointer head (one transformer layer) lets a question's options attend to each other and to the question, then scores every option.
4. Each question's scores are divided by its type's temperature, and a softmax is taken over that question's options.

Nothing is generated or sampled, and no answer is inserted into the input. A request longer than the context is answered in smaller groups of questions, each with the full state; a single question that does not fit on its own is rejected.

Calls

Call	What it does
MoDe.from_pretrained(name, revision=None, device=None, cuda_graphs=None)	Loads a model from the Hub or a folder. On a GPU it captures CUDA graphs at load (cuda_graphs=False skips this).
decide(state, questions)	Named questions over one state, in one pass.
decide_batch([{"state": ..., "questions": ...}, ...], batch_size=32)	Many requests, batched by length.

decide returns {question_id: {option_id: probability}}, in request order; each question's probabilities sum to 1.

Question types

type	Question	criteria	Answer keys
noul	Yes or no	optional descriptions of true and false	true, false
choice	One of several options	ordered {option id: description} (or null)	the option ids, in order
score	A point on an ordered scale	a list, lowest first	"0", "1", …

Supply at least one question; choice and score need at least two options. Calibrate any decision threshold on data from your own use.

Calibration

p = softmax(scores / T), with one temperature per question type, fitted for this checkpoint by minimising log-loss on held-out calibration records (never a benchmark test set) and clamped to T ≥ 1. It changes confidence, never which option is most likely. Stored in mode_config.json:

noul	choice	score	other
1.156	1.046	1.000	1.036

Performance

---

Benchmarks

Accuracy rises with size on the Decision Index and on all five of its areas. On the Intern-Decision suites, MoDe-M and MoDe-L are level (77.26 and 76.98 on average), each ahead on three of the seven.

Benchmark	MoDe S	MoDe M	MoDe L
Decision Index
Decision Index public suite (v0.3)	42.02	47.10	51.36
Knowledge	18.40	20.60	24.80
Language	40.90	46.60	51.30
Retrieval	54.50	62.50	65.30
Tools	61.60	68.40	75.20
Arts	45.10	47.00	48.80
Intern-Decision suites
Jevbench Easy	93.75	100.00	100.00
Jevbench Original	84.72	87.50	90.28
Jevbench Hard	36.94	47.75	44.14
Typed Decision	64.80	65.50	66.25
ToolACE	76.45	78.71	78.06
AG News	89.28	89.51	89.91
WildJailBreak	64.52	71.86	70.18
Seven-suite average	72.92	77.26	76.98

Evaluation details

Decision Index: all 140,178 requests of the public test set (v0.3), run with the benchmark's own evaluation tool on the released weights; 4 requests whose single question is longer than 8,192 tokens are refused and scored as wrong. Per-request results are in newrexlabs/decision-index-results; not yet verified by the benchmark's maintainers. Intern-Decision suites: the seven accuracy suites of the Intern-Decision cards, scored by their own harness and scorer unchanged (internlm/Intern-Decision @ 5653502, jevbench @ 7ce310c). None of their items appears verbatim in MoDe's training data; scored only on items without heavy training overlap, each size's average moves by at most 0.1.

Speed

All models below ran on the same card, a split (MIG) NVIDIA RTX PRO 6000, one request at a time, each with its authors' own inference engine. Sorted by median latency per request.

Model	Active params	Decision Index ↑	Median ↓	Mean ↓	p95 ↓
MoDe-S	0.28B	42.02	11.0 ms	19.1 ms	42.0 ms
Liquid AI d1-2Bc	1.92B	51.10	16.2 ms	159.1 ms	60.1 ms
Liquid AI d1-Omni-2Bc	2.17B	49.02	16.2 ms	160.3 ms	60.3 ms
MoDe-M	0.53B	47.10	17.7 ms	29.8 ms	71.8 ms
vLLM-SR d3-edge	0.59B	28.82	19.3 ms	39.4 ms	63.1 ms
MoDe-L	0.93B	51.36	25.0 ms	45.2 ms	107.6 ms
OneJev1.6-4B	4.54B	61.95	35.3 ms	117.8 ms	290.3 ms
vLLM-SR d3-nano	2.21B	42.22	40.1 ms	86.2 ms	178.5 ms
PKU-KCL-Meteor-0.8B	0.85B	58.77	40.3 ms	55.0 ms	107.7 ms
vLLM-SR d3-lite	0.85B	36.93	40.6 ms	70.1 ms	107.7 ms
PKU-KCL-Meteor-2B	2.21B	60.95	40.8 ms	69.4 ms	178.3 ms
Intern-Decision-2Br	2.27B	19.26	41.4 ms	44.2 ms	75.6 ms
Intern-Decision-0.8Br	0.87B	11.81	41.4 ms	40.9 ms	47.7 ms
GLiDE 2Bh	1.88B	60.64	41.9 ms	67.4 ms	176.2 ms
GLiDE 0.8Bh	0.75B	54.32	42.2 ms	54.5 ms	107.8 ms
vLLM-SR d3-mini	4.54B	54.90	54.2 ms	178.0 ms	442.4 ms
Intern-Decision-4Br	4.66B	38.00	55.2 ms	71.0 ms	191.1 ms

_{Bold: best in the column; underline: second best. MoDe rows are shaded. ^c compiled with model.compile(), the d1 card's fast path; the mean includes recompiles on new input shapes. ^h served over HTTP by the authors' own server, as submitted to the Decision Index. ^r refused 70 of the 700 requests (over 16 questions or 8,192 tokens); timed on the rest, which are the shorter ones.}

Measurement details

Five independent runs per model of the Decision Index board's latency design: 700 timed requests sampled by benchmark and length (seed 20260926), after 10 untimed warm-up requests, timed by the benchmark's own runner, bf16. Each model used the engine and settings its authors submitted or document (MoDe: CUDA graphs). The median shown is the median of the five run medians; MoDe's runs differ by under 0.6 ms. The card is split with MIG (2g.48gb, half the GPU), so these are not the board's full-card numbers. Decision Index scores are the board's public 0.3 scores; MoDe's are our full runs.

License and acknowledgment

---

MoDe-M is derived from MobileMoE-M by Meta and is released under the FAIR Noncommercial Research License (LICENSE), the licence of the base model: noncommercial research use only, subject to the FAIR Acceptable Use Policy. The weights were modified by decision fine-tuning, and this release adds the option-scoring head, the calibration and this model card. configuration_mobilemoe.py and modeling_mobilemoe.py are Meta's model code, loaded with trust_remote_code=True. We thank Meta for the MobileMoE models; please acknowledge MobileMoE in any publication that uses MoDe.

Citation

---

@misc{mode_2026,
  title        = {{MoDe}: Mixture of Deciders},
  author       = {{newrexlabs}},
  year         = {2026},
  howpublished = {\url{https://huggingface.co/newrexlabs/MoDe-M}}
}

For questions and feedback, open an issue on GitHub.