What Is Drex? Nace AI's Decision Model, Explained (Probabilities, Not Chat)

CodexFuse Team · 2026-11-06T22:38:53.965Z · 26 min read min read

What Is Drex?

The question "what is drex" has three answers on Google, and this article covers only one of them. Drex is Nace AI's decision model: you send it the facts of a case plus typed questions, and it returns a probability for every option in one forward pass, generating no text at all. The current open-weights release is Drex Max v1, a dense 27B-parameter model announced on 30 October 2026, scoring 67.52 on the public Decision Index 0.4.

The other two Drexes are easy to separate once you know they exist. Brazil's Drex is a central-bank digital currency pilot, the digital real, run by the Banco Central do Brasil, and it dominates the bare Google query. A cough syrup shares the name too, so any search without Nace AI or decision model in it will mix medicine and money with machine learning.

A decision model is a different kind of AI from a chat model. A chat model writes text token by token and names its answer at the end, while Drex scores the options you supplied and returns the numbers directly. That is the whole idea, and the rest of this guide fills in how it works, how to try it, and what it cannot do.

Drex runs locally through the same kind of local-model setup this site already covers, so if local models are new to you, work through the Ollama beginner guide first. The local path has a catch, though: there is no one-command Ollama install for Drex, and the Ollama section below explains the fork you need instead.

The short version is that Drex Max v1 answers typed questions about a state in text, JSON, or images, with three question types called choice, noul, and score. It runs on your hardware through Python, llama.cpp, Ollama, Kapitsa, or MLX, or as a hosted API at console.nace.ai. Everything here is current as of November 2026, and every benchmark number is Nace AI's own self-reported figure.

Drex in One Sentence: A Decision Model, Not a Chat Model

Drex is a decision model, not a chat model, and that one distinction explains everything else about it. You give it a state, which is the facts of the case as text, JSON, or images, plus named questions with fixed options. It returns a probability for every option in a single forward pass, and nothing is generated.

Nace AI puts it this way on its product page: an LLM writes text token by token and names an answer at the end, while Drex returns a probability for every option in a single pass, so truncation, malformed output, and invented options do not arise. The model can only answer with the options you gave it, which is a feature when the answer space is fixed and a hard limit when it is not.

That is what a drex decision model does: it judges instead of generating. That shape fits jobs where the answer is a pick, not a paragraph: agent routing, ticket triage, classification, guardrail checks, tool choice, and relevance judging. If your agent needs to choose which tool to call next, the LangChain beginner guide shows the agent framework where that choice lives, and Drex is the scorer that can make the call.

A typical Drex Max request answers in 183 milliseconds, according to Nace AI's technical report, against about 2.0 seconds for GPT-6 Sol and about 3.5 seconds for Claude Opus 5.5. That works out to roughly 10.9 times faster than GPT-6 Sol, which is the speed argument for a model that never writes a sentence.

Where Drex Came From: Six Weeks That Built a Model Family

Nace AI is a Palo Alto startup founded in the summer of 2024 by researchers and engineers from Google, Meta, Amazon, and the University of Toronto. It raised a 21.5 million dollar seed round led by Walden Catalyst in May 2026, with total funding reported at 26.5 million dollars. The company targets audit, compliance, and finance, where a wrong answer is expensive and a confidence score is a real requirement.

Searches for drex nace ai return Nace AI's own pages first, which is the fastest way to confirm you are reading about the model and not the currency. Drex itself arrived fast: Nace AI launched the first Drex on 24 September 2026, shipped Drex v2.0 on 6 October, open-sourced Drex v1.5 on 9 October, and put the hosted Drex Max live on 19 October. The open weights for Drex Max v1 followed on 30 October, 8 days before this article, and were widely reported on 1 November, 6 days before it, while a technical report landed on 6 November, one day before this article.

Two hosted products grew out of the same model in that window. Drex for Search, launched 26 October, is an agentic search tool that Nace AI says cuts agent steps by 62 percent and tokens by 56 percent across 6 professional-work benchmarks and 529 questions, and it works through a CLI, SDKs, an MCP server, or a REST API. If MCP is new to you, the what MCP is guide explains the protocol.

Drex for Finance, launched 2 November, is Drex Max trained further on financial decisions, scoring 77.3 on the Drex Finance Index across 48 public finance test sets it never saw in training. Both products are hosted services, not open weights, so they are not part of the open release this guide covers.

How a Drex Request Works: State, Questions, Probabilities

Every Drex request has the same two parts: a state and one or more named questions. The state is the case itself, as text, JSON, or images, and each question is typed, so the model knows exactly what shape of answer you want. The model scores each question in one forward pass over the state plus that question, and the pointer head turns the result into probabilities.

The example below comes from the drex huggingface model card for Drex Max v1, and it is the canonical first request: a support ticket, one choice question about which team should handle it, one yes-or-no question about a refund, and one urgency score. Note the shape of the state: a small JSON object with the ticket text, not a chat transcript.

from drex_max.model import DecisionModel, answer
model = DecisionModel("weights/drex-max-v1")
question = {
    "type": "choice",
    "instructions": "Which team should handle this ticket?",
    "criteria": {"billing": "Payments, charges, and refunds", "technical": "Bugs and outages", "other": "Anything else"},
}
row = {
    "state": {"ticket": "I was charged twice for the same order. Please refund the extra payment."},
    "question": question,
}
print(answer(question, model.predict([row])[0]))

The response shows why people reach for a decision model instead of a chat model. The team choice comes back as billing with a confidence of 0.9982 and probabilities of 0.9988 for billing, 0.0003 for technical, and 0.0009 for other, while the refund question returns a yes probability of 0.9974. The urgency score is 1.6522 on a 0 to 2 scale, with probabilities of 0.0152 for routine, 0.3173 for soon, and 0.6674 for urgent, and a confidence of only 0.4783, which is the model telling you the urgency call is genuinely close.

{
  "answers": {
    "team": {
      "type": "choice",
      "choice": "billing",
      "confidence": 0.9982,
      "probabilities": { "billing": 0.9988, "technical": 0.0003, "other": 0.0009 }
    },
    "refund": { "type": "noul", "noul": 0.9974 },
    "urgency": {
      "type": "score",
      "score": 1.6522,
      "legend": { "0": "Routine", "1": "Soon", "2": "Urgent" },
      "probabilities": { "0": 0.0152, "1": 0.3173, "2": 0.6674 },
      "confidence": 0.4783
    }
  }
}

Two numbers in that response deserve a second look. Confidence and probability are not the same field: the team choice has a confidence of 0.9982 against a top probability of 0.9988, and the urgency score has a confidence of 0.4783 even though urgent is the top option. Treat confidence as the model's own doubt meter, and never read a 0.99 probability as a business guarantee without testing calibration on your own cases.

The request format has hard edges worth knowing before you build on it. One request carries up to 16 questions with up to 255 options or levels each, according to the Drex specs reference, and the default limit is 16,384 tokens per request, rising to the 262,144-token window. Images travel in a separate images array and are visible to every question, but only on the Python GPU path, which the hardware section covers next.

How to Try Drex First: The Hosted API in Seven Steps

The fastest way to try Drex is the hosted API, because it needs no GPU and no 49 GB download. Nace AI offers a free trial with no card needed: paste a case, name the options, and get the probabilities back. The seven steps below take you from zero to your first scored decision.

1. Open console.nace.ai and create a Nace account.
2. Copy an API key from the console.
3. Pick the model id drex-max for the open-weights v1 behavior, or drex-max-v1.1 for the newer hosted model.
4. Write one state object with the facts of your case.
5. Add one typed question with named options.
6. Send POST /v1/systemone with the state and questions as JSON.
7. Read the probabilities, and check the top option against the confidence before acting on it.

The drex-latest alias does not route to Drex Max, so use the drex-max model id from step three. The request below is the same shape as the model card example, sent to the hosted endpoint instead of a local server. If APIs are new to you, the what an API is guide explains the request and response pattern first.

curl https://console.nace.ai/v1/systemone -H 'Content-Type: application/json' -H 'Authorization: Bearer YOUR_API_KEY' -d @request.json

Hosted pricing is per decision on the current product page: Drex Max v1.1 costs $0.03 per 1,000 decisions, against $3.33 for GPT-6 Sol and $10.17 for Claude Opus 5.5 per 1,000 decisions. That works out to 111 times cheaper than GPT-6 Sol and 339 times cheaper than Claude Opus 5.5 on that measure. Drex Max launched at $0.06 per 1 million input tokens with output tokens not billed, and published signup-credit figures disagree between the October launch coverage and the current product page, so no signup figure appears here.

How to Run Drex Max on Your Own Hardware

Self-hosting Drex Max v1 is real, and the model card documents every route, but the hardware gate is the first thing to check. The bf16 weights take about 49 GB on disk, the 8-bit load takes about 26 GB, and the ready-made Q8_0 GGUF file is 27.25 GB. A Mac with less than 24 GB of memory cannot run even the smallest Drex Max build, and images never run on the local Mac or CPU builds.

The Python path is the only route that sees images, and it needs Python 3.12 or newer plus a CUDA GPU. Nace AI tested bf16 on an H100 80 GB at 48.6 GiB loaded and 8-bit on an L40S 48 GB at 25.9 GiB loaded, and the 8-bit probabilities stayed within 0.03 of bf16 on the example request.

hf download nace-ai/drex-max-v1 --local-dir weights/drex-max-v1
pip install -r models/drex-max-v1/requirements.txt
python -m drex_max --model weights/drex-max-v1 --request examples/request.json

On a Mac, Kapitsa is the shortest path: it is Nace AI's Apple-silicon engine, and version 0.2.25 or later runs the text backbone. Install it, import the Q8_0 GGUF, write the readout head beside it, and start the server on port 8000. On a 48 GB Mac, use a 2,048-token context, and remember that images are not in the GGUF file.

brew install nace-ai/tap/kapitsa
export KAPITSA_HOME="$HOME/.cache/kapitsa"
hf download nace-ai/drex-max-v1-Q8_0 drex-max-v1-Q8_0.gguf --local-dir weights/drex-max-v1-Q8_0
GGUF=weights/drex-max-v1-Q8_0/drex-max-v1-Q8_0.gguf
kapitsa import "$GGUF" --name drex-max-v1
kapitsa-drex-pointer "$GGUF" "$KAPITSA_HOME/models/drex-max-v1/pointer.bin"
kapitsa-systemone --model "$KAPITSA_HOME/models/drex-max-v1" --port 8000 --context 2048

The llama.cpp route uses Nace AI's fork on the drex-max-v1 branch, and the conversion step is the slow part: it needs the bf16 weights, about 49 GB, on disk. Skip the conversion by downloading the ready-made Q8_0 GGUF from the nace-ai/drex-max-v1-Q8_0 repository instead. On the tested Apple M5 Pro with 48 GB of unified memory, the Q8_0 GGUF on Metal answered the example request within 0.02 of the bf16 H100 run.

git clone --branch drex-max-v1 --single-branch https://github.com/nace-ai/llama.cpp.git
cmake -S llama.cpp -B llama.cpp/build
cmake --build llama.cpp/build -j --target llama-server
python llama.cpp/convert_hf_to_gguf.py weights/drex-max-v1 --no-mtp --outtype q8_0 --outfile weights/drex-max-v1/drex-max-v1-Q8_0.gguf
llama.cpp/build/bin/llama-server -m weights/drex-max-v1/drex-max-v1-Q8_0.gguf -np 1 -c 16384 -b 16384 -ub 16384 --no-warmup --port 8000

Drex and Ollama: There Is No One-Command Install

Drex Max is listed on Hugging Face, so it is natural to assume you can pull it with Ollama, but that assumption is wrong. Drex is not in the Ollama library: a search of ollama.com returns nothing for it, and the Ollama decision-model category lists 12 models without Drex. There is no ollama pull drex command, and the official Ollama binary cannot run the model.

The drex ollama story is a fork, not a library entry, and the fork lives on the drex-max-v1 branch, built from source together with a llama-server built from Nace AI's llama.cpp fork. The Modelfile below is the whole configuration: it points at the GGUF file, declares the decision capability, and sets the context and GPU offload. On a 48 GB Mac, num_gpu 40 offloads 40 layers to Metal, and num_gpu 0 is the CPU setting.

FROM ./drex-max-v1-Q8_0.gguf
CAPABILITY decision
PARAMETER num_ctx 16384
PARAMETER num_gpu 40

Build the fork, start its daemon with the fork's own llama-server, import the model, and call the same /v1/systemone endpoint on port 11434. Ollama needs a model field in the request, which the jq filter below adds. Through Ollama on the tested Apple M5 Pro, the Q8_0 GGUF with num_gpu 40 gives the same answers as llama-server.

git clone --branch drex-max-v1 --single-branch https://github.com/nace-ai/ollama.git
cd ollama
export OLLAMA_LLAMA_CPP_SOURCE="$PWD/../llama.cpp"
cmake -S llama/server --preset darwin
cmake --build build/llama-server-darwin --target llama-server --parallel 8
GOTOOLCHAIN=auto go build -trimpath -o ollama .
cd ..
OLLAMA_HOST=127.0.0.1:11434 OLLAMA_LLAMA_SERVER="$PWD/ollama/build/llama-server-darwin/bin/llama-server" ollama/ollama serve
OLLAMA_HOST=127.0.0.1:11434 ollama/ollama create drex-max-v1 -f weights/drex-max-v1/Modelfile
jq '. + {model: "drex-max-v1"}' examples/request.json | curl http://127.0.0.1:11434/v1/systemone -H 'Content-Type: application/json' -d @-

The extra build step is the price of a model that was never packaged for stock Ollama. If you only want to evaluate Drex, the hosted API in the earlier section is the honest shortcut, and the fork is for teams that need the scorer inside their own infrastructure. CodexFuse offers no Drex tool, so this guide teaches the real project, not a CodexFuse page.

Drex vs Qwen: Same Family, Different Job

The cluster question behind Drex is what it owes to Qwen, and the answer is direct: Drex Max v1 is a decision fine-tune of Qwen3.8-27B from the Qwen3.5 family, according to the decision_config.json file in the model repository. The model card itself no longer names the base model, and its config.json lists only the model type qwen3_5, so cite the decision config file when you state the lineage.

What Drex adds is the decision machinery: the 255-way readout head, the non-causal attention layers, the vision tower, and training that rewards consistent decisions. What it removes is the entire generative side: Drex Max cannot chat, write prose, generate code, or explain itself. The honest frame is that the two models share a backbone family and do different jobs, and no published head-to-head benchmark pits Drex against Qwen, so this guide claims no winner.

The same logic explains the 22.9 percent parameter gap to Drex v2.0: Drex Max v1 is a dense 27B model while v2.0 is a 35B mixture of experts, 8 billion parameters heavier, and Drex Max still leads it by 6.27 points on the public Decision Index 0.4. Parameter count is not the score, and this pair proves it.

The Drex Family: v1.5, v2.0, Max, and Max v1.1

Drex is a family, not a single model, and the names blur together fast. Four open-weights models share the Drex name, plus a hosted-only upgrade, and each one answers a different question about size and speed: v2.0 is 32 days old, v1.5 is 29 days old, and the hosted Max is 19 days old. The table below is the map, so read it before you quote any single score.

Keep the three headline scores attached to their versions, because mixing them is the easiest mistake in this topic. The open-weights model is Drex Max v1 at 67.52 on Decision Index 0.4, the hosted v1.1 is 70.8, and the hosted launch model scored 67.59 on the older Index 0.3.2. Keep the two latency figures apart as well: 183 milliseconds is the v1 figure from the technical report, and 172 milliseconds is the hosted v1.1 median from the product page.

The family also explains where Drex sits inside an agent. A model like Browser-Use drives the browser and needs a scorer to pick the next tool or the next page, and a decision model is built for exactly that pick. The Browser-Use beginner guide covers the agent side, while Drex covers the scoring side, and the two belong together in a real deployment.

What the Benchmarks Say, and Who Reported Them

Every score below comes from Nace AI's own model card and product page, with no independent verification published yet. That is not a reason to dismiss the numbers, and it is a reason to read them as the vendor's report, not as a neutral leaderboard. The headline is the public Decision Index 0.4 score of 67.52, from 37 benchmarks in five areas, with 140,178 of 140,620 scoreable requests answered, which is 99.69 percent.

The area skills behind the headline show where the lead comes from: tools at 81.9, language at 72.2, retrieval at 68.8, knowledge and reasoning at 57.1, and arts at 53.4, against Drex v2.0 at 76.5, 65.3, 63.0, 47.9, and 53.9. Vision is the same story with a split personality: InfographicVQA at 97.3, KIE at 92.4, Winoground at 85.0, and Mind2Web at 84.2, against moderation at 40.6, R-Bench-M at 38.6, and MMMU-Pro vision at 47.3. A model can top an index and still be weak at spotting hateful memes, and the card prints both facts.

The honest counterweight comes from Nace AI itself: its product page FAQ admits Drex trails Jev 1.14 on MMLU-Pro, HLE, ARC-Challenge, and ARC-Easy. On the Artificial Analysis index, Drex Max sits fourth of 18 at 64, one point behind three leaders at 65 and ahead of Claude Haiku 5.5 (Low) at 61, Drex 2.0 at 58, and GPT-6 Luna (Low) at 55. Read the index as a decision-model ranking, not a general-intelligence ranking, and the placement makes sense.

from datetime import date
# Drex Max v1 vs Drex v2.0 on Decision Index 0.4 (same public suite, HF drex-max-v1 card)
print("lead over v2.0:", 67.52 - 61.25)
print("lead over Jev 1.13.0:", 67.52 - 57.96)
print("v1.1 lead over Jev 1.14:", 70.8 - 60.7)
# parameter gap vs v2.0
print("param gap B:", 35 - 27)
print("pct fewer params:", round(8/35*100, 1))
# latency ratio vs GPT-6 Sol (~2.0 s vs 183 ms)
print("latency ratio:", round(2000/183, 1))
# days
print("days open-weights announcement Oct 30 to Nov 7:", (date(2026,11,7)-date(2026,10,30)).days)
print("days MarkTechPost Nov 1 to Nov 7:", (date(2026,11,7)-date(2026,11,1)).days)
print("days v2.0 release Oct 6 to Nov 7:", (date(2026,11,7)-date(2026,10,6)).days)
print("days v1.5 announcement Oct 9 to Nov 7:", (date(2026,11,7)-date(2026,10,9)).days)
print("days hosted Max launch Oct 19 to Nov 7:", (date(2026,11,7)-date(2026,10,19)).days)
print("days tech report Nov 6 to Nov 7:", (date(2026,11,7)-date(2026,11,6)).days)
# benchmark fractions
print("jevbench pct:", round(213/231*100, 1))
print("decidebench pct:", round(1010/1071*100, 2))
print("answered share:", round(140178/140620*100, 2))
# sizes
print("Q8 GGUF GB:", round(27250125216/1e9, 2))
print("8bit share of bf16:", round(26/49*100, 1))
print("Q4 vs bf16 GB saved:", round(49-14.45, 2))
# cost: $0.03 per 1000 decisions vs GPT-6 Sol $3.33 and Claude Opus 5.5 $10.17
print("cost per decision cents:", 0.03/1000*100)
print("GPT-6 Sol multiple:", round(3.33/0.03, 1))
print("Claude Opus 5.5 multiple:", round(10.17/0.03, 1))

The arithmetic behind the claims in this article was recomputed from the fetched values with the short script above, run during writing. The lead over Drex v2.0 is 6.27 points, the lead over Jev 1.13.0 is 9.56 points, and the hosted v1.1 leads Jev 1.14 by 10.1 points. Drex Max carries 8 billion fewer parameters than v2.0, which is 22.9 percent fewer, and its 183-millisecond typical request is about 10.9 times faster than the 2.0 seconds quoted for GPT-6 Sol.

The License: Open Weights, Not Open Source

Drex Max v1 ships under the Nace.AI Open RAIL-M License (Modified), Version 1.0, October 2026, and the name needs care: the word open in it means the weights are freely accessible, not that the licence is open source. It is not an open-source licence, and Nace AI's own 6 November technical-report post calls all four models open source anyway, which contradicts the licence text. Follow the licence, not the blog post's loose wording.

The licence draws two hard lines in Attachment A. Commercial use is barred when you, your employer, or your affiliated entity generated more than 1 million dollars in gross revenue in the prior 12 months, or raised more than 1 million dollars in total equity or debt funding, except where use is limited to personal use or research. It is also barred for any product or service that competes with Nace AI's offerings, including decision models and document intelligence services, and a separate written commercial licence is required above the thresholds, through [email protected].

The use restrictions go further than money. Fully automated decisions with legal or similarly significant effects, covering employment, credit, housing, insurance, healthcare, education, immigration, and law enforcement, need meaningful human review, and the licence bars discrimination, medical, legal, or financial advice without appropriate qualified human oversight, plus military use, weapons development, mass surveillance, fraud, scams, spam, and deception. Small teams and individuals below both 1 million dollar thresholds can use the weights freely, and everyone else needs the commercial conversation first.

Seven Mistakes Beginners Make With Drex

Every row above comes from a real trap in the model card or the licence, not from imagination. The pattern is the same each time: Drex looks like a normal open model with a normal install story, and the fine print says otherwise. Read the card before you build, and the model behaves exactly as documented.

Sources

The Drex Max v1 model card on Hugging Face is the primary source for the architecture, the benchmarks, the hardware figures, and the request and response examples, and the Drex v2.0 card supplies the v2.0 figures and the JevBench comparison. Nace AI's product page at nace.ai/drex carries the hosted pricing, the v1.1 score, and the decision-model FAQ, while the 19 October launch post, the 26 October Drex for Search post, the 2 November Drex for Finance post, and the 6 November technical report fill in the timeline and the training method.

Independent coverage used for dates and cross-checks includes MarkTechPost's 1 November open-weights article and its 19 October hosted-launch article, Complete AI Training's 6 November explainer, CodeMyPixel's 3 November explainer, SoftTechHub's 5 November explainer, FourWeekMBA's 31 October licence analysis, AnchorTerminal's 30 October review, StartupFortune's Drex v2.0 piece, and the ssdnodes guide that lists Ollama's 12 decision models without Drex. The CBDC disambiguation rests on the Bank for International Settlements speech of 20 May 2025 and the CleanSky explainer with data as of 16 July 2026, and the Drex specs reference at systemonemodels.org supplies the per-request question and image limits.

Three facts could not be verified and are not asserted as facts here: the exact signup-credit amount, which disagrees between sources; the release date and weights status of the hosted-only Drex Max v1.1; and any independent verification of the benchmark scores. Search volume is unknown for every keyword in this article, download and like counts are a 2026-11-07 snapshot, and no testbed outputs were executed while writing.

Frequently Asked Questions

Is Drex the same as Brazil's Drex digital currency?

No, they only share a name. Brazil's Drex is a central-bank digital currency pilot run by the Banco Central do Brasil, while Nace AI's Drex is a decision model that returns probabilities for options you supply. Add Nace AI or decision model to your search when you want the AI model.

Is Drex open source?

No. Drex Max v1 is open weights under the Nace.AI Open RAIL-M License (Modified), which bars commercial use above 1 million dollars in revenue or funding and bars competing products entirely. Small teams and individuals below both thresholds can use it freely, and larger users need a commercial licence.

Can I run Drex with Ollama?

Not with stock Ollama, because Drex is not in the Ollama library and there is no ollama pull drex command. You need Nace AI's Ollama fork on the drex-max-v1 branch, built from source with a llama-server from Nace AI's llama.cpp fork, plus the Q8_0 GGUF file. The hosted API is the faster route if you only want to evaluate the model.

What hardware do I need to run Drex Max?

A Mac with 24 GB of memory or more runs the affine Q4 checkpoint, a Mac with 48 GB runs the Q8_0 GGUF, and the full model with images needs an H100 80 GB with bf16 weights or an L40S 48 GB in 8-bit. Local Mac and CPU builds are text only, so images need the Python GPU path. The bf16 weights take about 49 GB on disk.

Is Drex better than a chat model for decisions?

It is different, not strictly better: Drex returns probabilities for options you supply in one forward pass, while a chat model generates text and names its answer at the end. For fixed-option jobs like routing, triage, and tool choice, Drex is faster and cheaper on Nace AI's figures, at 183 milliseconds per typical request. For open-ended work that needs prose, code, or explanation, a chat model is still the tool, because Drex cannot generate text at all.