Drex Max v1: The First Open-Weight Decision Model That Runs on a 24 GB Mac

Nace AI's Drex Max v1 is the first open-weight decision model that runs on a 24 GB Mac. It outputs calibrated probabilities instead of text, replacing fragile LLM-based routing with a single forward pass.

The Problem: LLMs Are the Wrong Tool for Decisions

Every agent system needs to make decisions: route this ticket to billing or technical? Escalate this conversation to a human? Flag this screenshot as a policy violation? Today, most teams shove these decisions through an LLM — prompt it with the context, ask for JSON, parse the output, handle the hallucinations, retry on malformed responses. It works, but it’s the wrong abstraction. An LLM generates tokens sequentially; a decision model returns probabilities for every option in one forward pass. No token stream to parse, no JSON to repair, no invented options that weren’t in your schema.

Nace AI’s Drex Max v1, released as open weights on November 1, 2026, is the first model built explicitly for this paradigm that you can run on your own hardware ^[S1]. It’s a 27B dense multimodal model that takes state (text, JSON, images) plus typed questions — choice, yes/no, or score — and returns a probability distribution over up to 255 options. Nothing is generated ^[S1].

As MarkTechPost summarizes: “Nothing is generated. Questions come in 3 types: choice among named options, yes/no, and an ordinal score.” ^[S1]

How Drex Max Works: Architecture and Request Model

The backbone is a dense 27B parameter transformer with 64 layers: 48 Gated DeltaNet linear-attention layers (causal, left-to-right) and 16 full-attention layers (non-causal, every fourth layer) that let every token attend to the entire sequence ^[S1]. Images pass through a native vision tower and are visible to every question in the request. A 255-way readout head maps the final hidden state to option probabilities. The model card lists a qwen3_5 model type with a 262,144-token context window (16,384 default) ^[S3].

The request format is structured and unambiguous. You send a state object (your context) and one or more named questions, each with a type and criteria:

“json { "state": {"ticket": "I was charged twice for the same order."}, "question": { "type": "choice", "instructions": "Which team should handle this ticket?", "criteria": {"billing": "Payments, charges, and refunds", "technical": "Bugs and outages", "other": "Anything else"} } } “

The response returns probabilities for every option, not a single label:

“json { "answers": { "team": { "type": "choice", "choice": "billing", "confidence": 0.9982, "probabilities": {"billing": 0.9988, "technical": 0.0003, "other": 0.0009} } } } “

This is the core difference from LLMs: you get the full distribution. You can threshold on confidence, detect ambiguity (multiple high-probability options), or feed the probabilities directly into downstream logic. No post-hoc parsing required ^[S2].

As Nace AI explains: “Drex is a decision model: you send the facts of a case and typed questions, and it returns a probability for every option in a single pass. An LLM writes text token by token and names an answer at the end.” ^[S2]

Running Locally: The 24 GB Mac Threshold

The most consequential spec for most developers isn’t the benchmark score — it’s the hardware requirement. Drex Max v1 ships four ways to run locally [S1, S3, S4]:

The affine Q4 checkpoint is the breakthrough: it runs on Apple Silicon Macs with 24 GB of unified memory or more. That’s a MacBook Pro M3/M4/M5 Pro or Max — hardware many developers already own. On a 48 GB Mac, Nace recommends --context 2048 for Kapitsa. The Q8_0 GGUF needs 48 GB [S1, S3].

Images are text-only in the local GGUF/affine Q4 paths for now; vision requires the Python runtime on NVIDIA GPU ^[S3].

Quantization Holds Up — Nace’s Own Tests

Nace publishes quantization comparisons that are unusually transparent:

Q8_0 GGUF on M5 Pro 48 GB vs H100 bf16: max probability gap of 0.02 on the example request [S1, S3]
Affine Q4 vs Q8_0: max gap of 0.0329 across 21 fields at context 2,048; zero choice flips — no top answer changed after 4-bit quantization ^[S1]
8-bit backbone on L40S: stayed within 0.03 of bf16 ^[S1]

These are self-reported, but the test artifacts (Hugging Face datasets, model cards) are public and reproducible ^[S3]. The affine Q4 path is the first time a 27B-class decision model has been practical on 24 GB consumer hardware.

Benchmarks: Decision Index, Vision, and the Jev Comparison

Drex Max v1.0 scores 67.52 on the public Decision Index 0.4 (37 benchmarks, 140,620 scored requests) and 73.92 on the public vision index (11 benchmarks, 12,210 rows) ^[S3]. The v1.1 update raises the Decision Index to 70.8 ^[S2].

| Model | Decision Index 0.4 | JevBench | Decision Bench v4 | Vision Index | |——-|——————-|———-|——————-|————–| | Drex Max v1.1 | 70.8 | 93.9% | 94.2% | 75.9 | | Drex Max v1.0 | 67.52 | 92.2% | 94.30% | 73.92 | | Drex v2.0 (35B MoE) | 61.25 | 85.7% | 88.3% | — | | Jev 1.14 | 60.7 | 86.7% | 92.3% | 63.9 |

Drex Max beats Jev 1.14 by +10.1 on Decision Index and +12.0 on vision index ^[S2]. It trails Jev on MMLU-Pro (75.2 vs 82.1), HLE (18.2 vs 19.4), and ARC benchmarks — expected, since Jev is a general-purpose LLM and Drex is specialized for decisions ^[S2].

Vision benchmarks are where Drex Max v1.1 pulls ahead decisively against GPT-6 Luna Decisions: InfographicVQA 98.4 vs 93.8, Winoground 93.4 vs 83.8, CV-Bench 86.3 vs 73.8, BLINK 75.0 vs 63.7 ^[S2]. For agent builders doing computer-use tasks (screenshot → decision), this matters.

What This Replaces in Your Stack

If you’re currently using an LLM for any of these, Drex Max is a direct architectural improvement:

Agent routing: Which tool/skill/agent handles this request? → single forward pass, full probability distribution over your registered tools
Ticket triage / support classification: The example in the model card is literally a support ticket router ^[S1]
Guardrail / policy checks: Does this output violate policy X? → yes/no with calibrated probability, not a generated explanation you then parse
Search relevance / reranking: Score (0-10) or choice among result candidates with confidence intervals
Computer-use agents: Screenshot → next action (click, type, scroll) as a choice question; Drex Max v1.1 answers in 172 ms median API latency ^[S2]

The API is wire-compatible with Jev — switching takes three environment variables ^[S2]. Self-hosted, the per-decision cost drops to zero (vs $0.03/1K hosted at launch pricing) [S2, S3].

Limitations and Honest Constraints

Text-only locally: Vision requires Python + NVIDIA GPU. The affine Q4 and Q8_0 GGUF paths don’t include the vision tower [S1, S3]
Self-reported benchmarks: All Decision Index, JevBench, and vision scores come from Nace AI’s own evaluation runs. Independent reproduction is limited [S1, S3]
27B dense = heavy: Even at 4-bit, 14.45 GB is most of a 24 GB Mac’s usable memory. You’re not running much else alongside it ^[S1]
Decision Index 0.4 methodology: Chance-corrected skill × 100; unanswered requests count as wrong. The index averages 37 benchmarks across five areas. It’s a decision-specific benchmark, not a general capability measure ^[S3]
Preview status: v1.1 labeled “New” on Nace site; open weights are v1.0 ^[S2]
License: Weights under Nace.AI Open RAIL-M; code under Apache-2.0 ^[S4]

The Practical Takeaway

Drex Max v1 is the first open-weight decision model that crosses the consumer-hardware threshold. If you’re building agent systems on Macs, you can now replace LLM-based routing/classification/guardrails with a purpose-built model that returns calibrated probabilities in one pass, runs offline, and costs nothing per decision. The affine Q4 on a 24 GB Mac is the inflection point — it makes local decision models practical for individual developers, not just GPU clusters.

For teams already on NVIDIA infrastructure, the Python/bf16 path with vision support is available today. For everyone else, the Mac path is real and the quantization data suggests it’s not a compromised experience.

The model won’t replace your LLM for generation tasks — it doesn’t generate. But for the decision layer that sits between your agent’s perception and its action, it’s the right tool for the first time.

Sources

[S1] Nace AI Open-Sources Drex Max v1: A 27B Decision Model That Runs Locally on Apple Silicon — MarkTechPost (2026-11-01)
[S2] Drex Max, the decision model that sees | Nace.AI — Nace AI (official) (2026-11-01)
[S3] nace-ai/drex-max-v1 · Hugging Face — Hugging Face (model card) (2026-10-19)
[S4] GitHub – nace-ai/drex-decision-models: Open Drex decision models — GitHub (Nace AI) (2026-10-14)