In This Guide
- What Is Drex Max Open Weights?
- How Drex Max Open Weights Make Decisions
- Drex Max Open Weights Benchmarks, Explained Honestly
- Drex Max Open Weights Hardware Requirements
- What You Can Build With Drex Max Open Weights
- Drex Max Open Weights vs the Hosted Drex Max API
- Drex Max Open Weights vs Chat Models and Other Open Models
- Open Weights Is Not Open Source: The Drex Max Open Weights Licence
- How to Get Started With Drex Max Open Weights
- Limitations to Know Before You Download Drex Max Open Weights
- The Honest Verdict on Drex Max Open Weights
- Frequently Asked Questions About Drex Max Open Weights
Drex Max open weights are the downloadable version of Nace AI’s most capable decision model, released on 1 November 2026. Unlike the chatbots most people associate with AI, this 27-billion-parameter model never writes a sentence. Instead, you hand it a situation — text, a JSON record, or even a screenshot — plus a set of named questions, and it returns a probability for every option you offered, in a single forward pass. If you have ever wished an AI model would stop rambling and simply answer “how likely is each outcome?”, Drex Max open weights are built exactly for that job.
The release matters for a practical reason: decision-making is the unglamorous work inside almost every AI agent. Before an agent clicks a button, routes a support ticket, approves a refund, or flags a document, somebody has to decide. Until now, most developers made that decision by asking a chat model to generate text and then parsing the answer — a slow, fragile pattern where the model can wander outside the allowed choices. Drex Max open weights remove the parsing step entirely. The model can only answer inside the options you define, which makes its output predictable enough to wire directly into software.

Drex Max open weights turn a Mac or a GPU workstation into a local decision engine — no chat window, no generated text, just probabilities.
What Is Drex Max Open Weights?
Drex Max is the flagship model in Nace AI’s Drex family, a line of models designed for one purpose: making decisions. The company, based in Palo Alto, first shipped smaller decision models in September 2026, then launched the hosted Drex Max in October. The 1 November release is different because it puts the weights themselves into developers’ hands. You can download them, run them on your own hardware, and keep the whole decision process on a machine you control.
It helps to think of Drex Max open weights as a judge rather than a writer. A chat model reads a prompt and writes the next word, over and over, until it stops. Drex Max reads the full context once and scores every candidate answer at the same time. There is no draft, no revision, and no chance of it inventing an option you never offered. For software that must behave the same way every time, that constraint is a feature, not a limitation.
The model itself is a dense 27-billion-parameter system with a 64-layer backbone. According to the release coverage, it combines 48 Gated DeltaNet linear-attention layers with 16 non-causal full-attention layers — a hybrid design meant to handle very long inputs efficiently. Its context window stretches to 262,144 tokens, with 16,384 tokens as the default per request, so it can absorb long documents, detailed case files, or multi-screen workflows before it decides. The Jev Decision Index listing describes it as built on a Qwen3.8-27B base, which places it in the same weight class as the current generation of strong open models, but aimed at a completely different job.
One distinction matters from the start. Drex Max open weights are the 1 November release of version 1, and they should not be confused with the hosted Drex Max launch of 19 October. The hosted launch was scored on Decision Index 0.3.2, where Nace reported 67.59. The open-weights release is scored on the newer Decision Index 0.4, where the figure is 67.52. Those two numbers come from different benchmark editions, so they are not directly comparable — a point worth remembering whenever you see a headline quoting one of them.
How Drex Max Open Weights Make Decisions
Using Drex Max open weights starts with a different mental model than chatting. You do not write a prompt and wait for prose. You send a “state” — the facts of the case — and a list of typed questions, and you get structured answers back. Every question carries its own options, and the model returns a probability for each one.
Three Question Types in Drex Max Open Weights
Drex Max open weights support three question types, and choosing the right one is half the skill of using the model well. A yes/no question returns a single probability: how likely is the answer “yes”? That fits checks like “is this invoice overdue?” or “does this screenshot show an error dialog?” A choice question offers between 1 and 255 labelled options and returns the most likely option together with the full probability distribution across all of them. That fits routing: “which department should handle this ticket — billing, technical, or refunds?” An ordered-level question, also with up to 255 levels, returns an expected level with per-level probabilities and a legend — ideal for graded judgements such as urgency on a scale from 1 to 5, or a quality score.
The probability distribution is the real product here. A chat model that answers “billing” gives you one word and no sense of its confidence. Drex Max open weights tell you billing is 72% likely, technical is 21%, and refunds is 7%. Your software can then act on that uncertainty: auto-route when confidence is above 90%, ask a human when it is below 60%, and log the borderline cases for review. That is how you build automation that degrades gracefully instead of failing confidently.
One Forward Pass, No Text to Parse
The reason Drex Max open weights can offer that distribution is that they never generate tokens. A single forward pass scores every option simultaneously, which is why Nace reports decisions in under 200 milliseconds on the hosted service — the product page quotes a median of around 172 milliseconds per decision. Local speeds will vary with your hardware and checkpoint, but the architecture removes the biggest source of latency in chat-based decisions: waiting for a paragraph to be written word by word.
There is a second, quieter benefit. Because the output is a fixed set of numbers, it is trivially testable. You can run ten thousand historical cases through Drex Max open weights, compare its probabilities against what actually happened, and measure calibration — how often its 80% predictions were right about 80% of the time. Try doing that with free-form text and you will spend most of your time arguing about what the model meant. For teams that must audit their automation, structured output is not a nice-to-have; it is the whole point.
The 255-Option Readout Head
Under the hood, Drex Max open weights use a 255-way readout head, which is simply the mechanism that turns the model’s understanding of the context into one probability per option. Up to 255 options per question is generous: most real routing and classification problems need a dozen or fewer. The practical limit to watch is different — Drex Max accepts up to 16 questions per request, with up to 8 images in a separate images array, and each question can reference all the images in that request. That makes it a natural fit for screen-reading agents: feed it a screenshot plus questions like “what is the current step?”, “is the checkout button visible?”, and “has an error appeared?” and get a full situational picture in one call.
Developers already familiar with the Drex family will find the interface familiar. Drex Max open weights serve the same POST /v1/systemone API as the other Drex models, so code written against the hosted API transfers to a local deployment with minimal changes. That compatibility is deliberate: Nace wants the local release to feel like the same product, running on your hardware instead of theirs.

With Drex Max open weights, a developer defines the options up front — the model never answers outside them.
Drex Max Open Weights Benchmarks, Explained Honestly
Every number in this section is company-reported by Nace AI. No independent lab has re-run these benchmarks on the open-weights release at the time of writing, so treat them as Nace’s own claims about its model, not as verified facts. That caveat matters more than usual here, because decision benchmarks are newer and less standardised than the chat benchmarks most readers know.
The headline figure is 67.52 on the public Decision Index 0.4, a suite that scores models on deciding rather than writing. Nace says that is 6.27 points ahead of its own Drex v2.0 at 61.25, and ahead of Jev 1.13.0 at 57.96. The Decision Index is chance-corrected, meaning a random guess scores zero, and unanswered requests count as wrong — so the gap is meaningful if the methodology holds up. The results dataset covers 140,620 scored requests, which is a large sample by benchmark standards.
Beyond the headline, Nace reports 97.3 on InfographicVQA, a visual reasoning test that asks questions about charts and infographics, and 81.9 in the Tools area of the index, which covers tool-use decisions. Artificial Analysis, an independent benchmark tracker, scores Drex Max at 64 on its own Decision Index, which Nace says ranks 4th of 18 models tracked. The gap between Nace’s 67.52 and Artificial Analysis’s 64 is a useful reminder that different scorers get different numbers — the honest way to read both is “strong on decision tasks, exact rank depends on who is measuring.”
What the benchmarks do not tell you is just as important. They do not measure how well Drex Max open weights handle your specific cases — your ticket categories, your document formats, your screenshots. Decision models live or die on the distribution of cases they see in production, and a benchmark built from public suites is only a starting signal. The right move is to run your own evaluation: take a few hundred historical cases where you already know the right answer, run them through the local model, and check whether its high-confidence answers are actually right. The open-weights release makes that test free except for your time, which is precisely why it matters.
Drex Max Open Weights Hardware Requirements
Drex Max open weights ship in several formats, and the one you pick decides what hardware you need. The full bf16 weights weigh in at about 49 GB and are meant for datacentre-class NVIDIA GPUs — Nace names the H100 for bf16. The 8-bit build is about 26 GB, with the Q8_0 GGUF at 27.25 GB, aimed at 48 GB cards such as the L40S. The smallest option, the affine Q4 checkpoint at 14.45 GB, is the one that brings the model within reach of a good desktop.
| Checkpoint | Size | Hardware needed |
|---|---|---|
| bf16 weights | ~49 GB | NVIDIA H100 or similar datacentre GPU |
| Q8_0 GGUF | ~27.25 GB | 48 GB GPU (e.g. L40S) or 48 GB Apple Silicon Mac |
| 8-bit build | ~26 GB | 48 GB GPU |
| Affine Q4 checkpoint | ~14.45 GB | Apple Silicon Mac with 24 GB+ unified memory |
For Mac users, the headline is simple: a Mac with at least 24 GB of unified memory can run the affine Q4 checkpoint through Kapitsa or MLX, while the Q8_0 GGUF needs 48 GB. Coverage of the release notes that on a 48 GB Apple M5 Pro, the Q8_0 build matched H100 bf16 output within 0.02 per probability — an encouraging sign that a local machine can approximate datacentre output closely enough for most routing and classification work. CPU-only runs are possible through the llama.cpp and Ollama forks Nace ships, though they will be slower, and they suit batch jobs better than real-time decisions.
There is one hardware catch to plan around: local Mac and CPU paths are text only for now. If your use case needs the model to read screenshots or images, you need the Python implementation on an NVIDIA GPU. Teams building screen-reading agents on a Mac should therefore treat the local release as a text-decision engine first, and keep image decisions on the hosted API or a GPU workstation until the local vision path catches up.

Drex Max open weights are most useful where a team already makes the same judgement hundreds of times a day.
What You Can Build With Drex Max Open Weights
The best way to understand Drex Max open weights is through the jobs they replace. Each of these is a decision a team currently makes by hand, or by parsing chat output, and each becomes a structured call with a probability attached.
Support ticket routing and triage. A support inbox is a classification problem wearing a trench coat. Every incoming message needs a department, an urgency level, and sometimes a frustration score. Drex Max open weights can return all three in one request: department as a choice question, urgency as an ordered level, and a yes/no check for “does this customer mention cancelling?” Because the output is a distribution, you can auto-route the confident cases and send the uncertain ones to a human queue — the exact pattern that keeps automation from becoming a complaint generator.
Policy and compliance checks. Many business rules are really yes/no questions with paperwork attached: does this expense claim match policy? Does this listing violate a marketplace rule? Does this document contain a required disclosure? A decision model answers these without the risk of a chat model “helpfully” rewriting the policy in its reply. And because the weights run locally, the documents being checked never leave your machine — a genuine advantage for finance, legal, and healthcare-adjacent workflows where sending data to a third-party API is a non-starter.
Computer-use and browser agents. This is the use case Nace emphasises most. An agent that operates software needs to read screens and decide the next action, dozens of times per task. Drex Max open weights read text, JSON, and images, and answer questions about what they see: which button is the checkout button, whether a form is complete, whether an error appeared. The under-200-millisecond decision time matters here because an agent that pauses for seconds at every step feels broken. Note the Mac text-only caveat above — screen reading still wants a GPU for now.
Document and delivery verification. The same pattern works wherever a human currently eyeballs something against a record: delivery notes against purchase orders, identity documents against application forms, invoice line items against contracts. A warehouse team could photograph a delivery, ask whether each item matches the manifest, and get a probability per item. The model does not replace the final human sign-off, but it turns “check everything” into “check the five items the model is unsure about.”
Content and quality scoring. Ordered-level questions make Drex Max open weights a natural quality gate: score draft responses, rate the completeness of a report, or grade the relevance of a search result on a fixed scale. Because the scale is yours, the scores stay comparable over time in a way that free-text judgements never are.
Drex Max Open Weights vs the Hosted Drex Max API
Running Drex Max open weights locally is not automatically better than using the hosted API — it is a different trade, and the right choice depends on what you value most. The hosted Drex Max API charges $0.06 per million input tokens, with $25 of free credit at signup, and it handles the full multimodal workload including images and video on Nace’s infrastructure. If you need image decisions today, or you process a modest volume, the hosted API is the simpler path: no downloads, no GPU, no quantisation choices.
Local deployment flips the cost structure. The weights are free to download, so your costs become hardware and electricity instead of per-token billing. At high volume — a support operation classifying a million tickets a month, or an agent fleet making millions of micro-decisions — that difference compounds fast. Local runs also remove the network round trip, which matters for latency-sensitive agents, and they keep sensitive inputs on your own machines, which matters for regulated data.
The trade-offs run the other way too. You take on the work of hosting: choosing a checkpoint, keeping the runtime updated, and accepting that Mac and CPU deployments are text-only for now. You also take on the accuracy question — the Q4 checkpoint is smaller and faster than bf16, and while the reported 0.02 probability gap on a 48 GB Mac is small, it is not zero, and your own evaluation should confirm it on your cases. A sensible pattern is to prototype on the hosted API, where iteration is fast, and move to Drex Max open weights locally once the decision logic is proven and the volume justifies it.
One more note for readers checking Nace’s website: the company’s product page now highlights a newer hosted Drex Max v1.1. This article covers the 1 November open-weights release of Drex Max v1, which remains the downloadable version discussed here. If Nace later publishes v1.1 weights, the same decision-model logic will apply, but the benchmark figures will be different — check the model card before quoting numbers.

Support triage is the clearest early win for Drex Max open weights: department, urgency, and escalation risk in one call.
Drex Max Open Weights vs Chat Models and Other Open Models
Comparing Drex Max open weights with a chat model is a category error, but it is one almost everyone makes, so it is worth spelling out. A chat model is a generalist: it can write, summarise, code, and reason, and it can also be coaxed into making decisions by asking it to output a label. But its decision is a side effect of text generation, which means it can produce a label you never listed, hedge in prose, or change its answer if you rephrase the question. Drex Max open weights do one thing and refuse to do anything else — that refusal is the product.
The comparison that does make sense is with the site’s other open-weight coverage. Mistral Large 4’s open weights give you a powerful general-purpose model you can host yourself, and running AI models locally on a Mac is the same self-hosting impulse applied to coding tools. Drex Max open weights sit one layer below those: they are not the model you chat with, but the model your agent consults when it needs a reliable yes, no, or “which one” before acting. Teams building agents will often use both — a chat model to plan, and a decision model to commit.
There is also a useful contrast with the agent-model wave the site has covered recently, including DeepSeek’s Super Agent work. Those systems expand what agents can attempt. Drex Max open weights address the opposite risk: agents attempting too much, too confidently, with no calibrated sense of doubt. A probability distribution is a humble output, but humility is exactly what production automation needs. When an agent can say “I am only 54% sure this is the right button,” a human can step in before the wrong button is pressed.
Open Weights Is Not Open Source: The Drex Max Open Weights Licence
Drex Max open weights are released under the Nace.AI Open RAIL-M licence, and the distinction between “open weights” and “open source” is worth stating plainly. You get the weights and the right to run them, but you do not get the training data, and the licence is not a permissive open-source licence like Apache 2.0 or MIT. It carries use restrictions, and responsible-use conditions travel with the model.
The restrictions that matter most for business users are the ones around high-stakes automated decisions. The licence prohibits fully automated decision-making in employment, credit, housing, insurance, healthcare, education, immigration, and law enforcement without meaningful human review, along with discrimination based on legally protected characteristics, and medical, legal, or financial advice or decisions without qualified human oversight. Uses for military weapons, mass surveillance, fraud, and spam are also barred. None of this blocks the mainstream uses — routing, triage, policy checks, agent navigation — but it does mean you cannot legally deploy Drex Max open weights as an unreviewed hiring filter or loan decider. If your use case touches a regulated decision, keep a human in the loop and document it.
Practically, the licence also means you should read the model card on Hugging Face before building anything commercial on top of the weights. Licences in this space evolve — Nace could revise terms for future versions — and the model card is the authoritative source at download time, not a blog summary. The upside of open weights remains: no vendor can switch off your model, change its pricing overnight, or see your inputs. That independence is real, even within a restrictive licence.

Local decision models shine where data cannot leave the building — warehouses, clinics, and finance teams included.
How to Get Started With Drex Max Open Weights
Getting started with Drex Max open weights is a developer task, not a consumer download — there is no app to install and no chat window to open. The path below assumes you are comfortable with a terminal and have the hardware from the table above.
- Check your hardware first. On a Mac, confirm you have at least 24 GB of unified memory for the affine Q4 checkpoint, or 48 GB for Q8_0. On a PC, confirm your GPU memory against the checkpoint table. Downloading 14 to 49 GB of weights onto a machine that cannot run them is a frustrating way to spend an evening.
- Get the weights from Hugging Face. The release lives on the nace-ai organisation page as drex-max-v1, in bf16, Q8_0 GGUF, and affine Q4 formats. Read the model card there — it is the authoritative source for formats, limits, and licence terms.
- Pick a runtime. Nace ships forks of llama.cpp and Ollama for local inference, and Kapitsa or MLX paths for Apple Silicon. NVIDIA users run the Python implementation, which is also the only path that currently supports image inputs.
- Define your questions before your first run. Write down the exact options for each decision and the confidence threshold at which a human reviews the result. A decision model is only as good as the question set you give it — vague options produce vague probabilities.
- Evaluate on your own cases. Run a few hundred historical cases with known outcomes through the model and check calibration: are its 90% answers right about 90% of the time? Adjust thresholds, not the model, until the numbers behave.
- Wire it into one workflow. Start with a single high-volume, low-risk decision — ticket routing is the classic first deployment — and keep the human-review queue visible. Expand to more decisions only after the first one earns trust.
If you would rather test the decision-model idea before committing hardware, the hosted Drex Max API with its $25 signup credit is the low-friction trial. The request format is identical, so anything you build against the API ports to your local deployment later.
Limitations to Know Before You Download Drex Max Open Weights
Drex Max open weights are a strong release with real edges, and naming them now saves disappointment later. First, the benchmarks are vendor-reported and the model is days old — independent evaluations will arrive, and some numbers may move. Second, local Mac and CPU deployments handle text only, so screen-reading agents still need a GPU or the hosted API. Third, the model answers only within the options you define, which means a missing option is a silent failure: if the true answer is not on your list, the model will confidently distribute probability across the wrong answers. Designing complete option sets is a genuine skill, and it deserves as much attention as the model itself.
Fourth, the 262,144-token window is a ceiling, not a promise: long states above 8,192 tokens are truncated to the most relevant parts on the hosted service, and only tokens actually read are billed — local behaviour will depend on your runtime, so test long-context cases explicitly. Fifth, the licence restricts high-stakes automated decisions without human review, which rules out some of the most tempting deployments. And finally, this is a developer tool: there is no polished consumer interface, no one-click installer, and no support line. If your team has no one comfortable running local models, the hosted API — or a different product entirely — is the honest recommendation.
The Honest Verdict on Drex Max Open Weights
Drex Max open weights are not the most exciting AI release of November 2026, and that is precisely why they are worth covering. The AI industry spends most of its energy on models that talk more fluently; this is a model that talks not at all, and instead gives software something it has always needed — a number it can act on, with a measure of doubt attached. For developers building agents, support automation, or compliance checks, that is a genuinely useful new building block, and the fact that it runs on a 24 GB Mac removes the datacentre excuse for not trying it.
The release is not for everyone. If you want a chatbot, look elsewhere. If you want to replace human judgement in hiring, lending, or medical decisions, the licence says no, and good practice agrees. But if you run a workflow where the same decision is made hundreds of times a day, where wrong answers have a cost, and where knowing the model’s confidence matters as much as its answer, Drex Max open weights deserve a weekend evaluation. Download the Q4 checkpoint, run your own cases, and let your own calibration numbers — not a vendor benchmark — decide whether it earns a place in your stack.
Frequently Asked Questions About Drex Max Open Weights
What are Drex Max open weights in simple terms?
Drex Max open weights are the downloadable files for Nace AI’s 27-billion-parameter decision model. Instead of generating text, the model takes a situation plus named questions and returns a probability for every option you offered, in one forward pass. You run it on your own Mac or GPU instead of calling Nace’s hosted API.
How much do Drex Max open weights cost?
The weights themselves are free to download under the Nace.AI Open RAIL-M licence. Your costs are hardware and electricity: a Mac with 24 GB or more of memory for the Q4 checkpoint, or a 48 GB GPU for the larger builds. The hosted Drex Max API, by comparison, charges $0.06 per million input tokens with $25 of free signup credit.
Can Drex Max open weights run on a Mac?
Yes, with conditions. A Mac with at least 24 GB of unified memory can run the affine Q4 checkpoint via Kapitsa or MLX, and a 48 GB Mac can run the Q8_0 GGUF. Local Mac runs are text only for now — image inputs need the Python implementation on an NVIDIA GPU.
Do Drex Max open weights generate text?
No. That is the defining feature. Drex Max open weights never generate tokens; they return probabilities for the options you define. If you need generated text, pair them with a chat model — use the chat model to plan and the decision model to commit.
Are Drex Max open weights open source?
No, and the distinction matters. Open weights means the model files are public and runnable, but the training data is not published and the Nace.AI Open RAIL-M licence restricts certain high-stakes uses, including fully automated decisions in employment, credit, housing, and similar areas without meaningful human review.
How accurate are Drex Max open weights?
Nace reports 67.52 on the public Decision Index 0.4, ahead of Drex v2.0 at 61.25 and Jev 1.13.0 at 57.96, with 97.3 on InfographicVQA. All figures are company-reported and not yet independently verified on the open-weights release, so run your own evaluation on your cases before trusting the numbers in production.
Sources: Nace AI’s Drex product page and Introducing Drex Max announcement; the Drex Max v1 model card on Hugging Face; MarkTechPost’s 1 November 2026 coverage of the open-weights release.
