nace-ai/drex-v1.5

Drex v1.5

A decision model from Nace.AI: it reads a state (text or JSON) and typed questions (choice, noul, ordinal score) and returns a probability for every option in one forward pass per question. Nothing is generated. It serves the TypeSafe-compatible /v1/systemone API through the bundled Kev code, the same request and response format as the hosted Drex API and the open Drex DLM.

Drex v1.5 is the #1 model under 10B parameters on the public Decision Index 0.3.1 (58.08).

Drex repository · Drex DLM · Hosted API docs · Agent skill

Model

Backbone	Qwen3_5ForCausalLM, 32 layers, hybrid attention (3 linear-attention layers for every full-attention layer)
Parameters	about 9B (8.95B), bf16 weights, about 18 GB on disk
Pointer head	head.pt, scores each option from the backbone's hidden states
Context	16,384 tokens by default, up to 131,072; long-document accuracy is reported up to 128k tokens (see Performance)
Base model	XiaomiMiMo/MiMo-V2.6-Distill-Qwen-9B

Performance

Decision Index 0.3.1 (public only)

Model	Public index	Raw	Knowledge & Reasoning	Language	Retrieval	Tools	Arts
Drex v1.5 (9B)	58.08	68.08	44.6	60.4	61.7	75.0	48.8
Jev 1.13.0	57.96	68.55	53.9	59.2	55.4	75.1	39.1
Bespoke Nimble 9B v3	57.19	68.38	41.0	60.7	55.5	84.2	44.0
Cloudflare clef-flash	56.15	66.53	53.0	47.2	52.2	81.9	48.4
ezjev 4B s2	50.82	63.16	31.0	60.5	56.3	69.9	31.1

Public index only: the 37 public benchmarks in five areas, without the private tests. Area columns are chance-corrected skill × 100. The table shows Drex v1.5, Jev and the top three other models under 10B parameters on the leaderboard. The Drex v1.5 numbers are from our own run of the official kit on the full public suite (the text suite is the same in 0.3 and 0.3.1); the other rows are the leaderboard's. Drex v1.5 is the highest-scoring model under 10B parameters; Jev's parameter count is not published. Drex v1.5, Jev and Nimble are within the board's 0.9-point tie band. Drex v1.5 is ahead of Jev on 20 of the 37 benchmarks.

JevBench (231 public items)

Model	Accuracy	Easy	Standard	Hard
Jev 1.13.0	87.0%	100.0%	98.6%	73.9%
Drex v1.5	86.2%	100.0%	95.8%	73.9%
decider-4b v2.1	83.1%	100.0%	98.6%	65.8%

Long-context benchmarks

Context length	Accuracy	Truncated to 8k	Median latency
8k – 32k tokens	89.5%	76.5%	0.65 s
32k – 128k tokens	93.4%	78%	2.0 s

Long documents with typed questions; every request was answered.

Game arena against Jev

Eight OpenSpiel games, 32 games each (16 openings × both colours): 122 wins, 47 draws, 87 losses (56.8%).

Inference

Requirements

• Python with the packages in requirements.txt (torch, transformers).
• A CUDA GPU for inference.py and serve.py. The bf16 weights are about 18 GB, and memory use grows with document length.
• Apple silicon (Metal) and CPU: use llama.cpp or Ollama below. The Q8_0 GGUF is about 9.5 GB.

Score a request from the command line

hf download nace-ai/drex-v1.5 --local-dir drex-v1.5
cd drex-v1.5
python -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt
python inference.py                                    # built-in example
python inference.py --request examples/request.json    # your own System One request

inference.py loads the checkpoint in its own folder (--model selects another) and prints the answers as JSON.

Serve over HTTP

python serve.py --port 8000
curl http://127.0.0.1:8000/v1/systemone \
  -H 'Content-Type: application/json' -d @examples/request.json

The endpoint is POST /v1/systemone and needs no Authorization header; GET /health returns {"status": "ok", "model": "drex-v1.5"} once the weights are loaded. A request can also be {"requests": [...]} to score several decisions in one call. The server listens on 127.0.0.1; keep it there unless you put authentication in front of it.

Run with llama.cpp

git clone -b drex-v1.5 https://github.com/nace-ai/llama.cpp && cd llama.cpp
cmake -B build && cmake --build build -j --target llama-server llama-quantize

python convert_hf_to_gguf.py ../drex-v1.5 --no-mtp --outtype bf16 --outfile drex-v1.5.gguf
./build/bin/llama-quantize drex-v1.5.gguf drex-v1.5-Q8_0.gguf Q8_0     # optional, about 9.5 GB

./build/bin/llama-server -m drex-v1.5.gguf --embedding --pooling none \
  -np 2 -c 32768 -b 16384 -ub 2048 --port 8000

The server answers POST /v1/systemone with the same request and response as above. Use -np 2 so the state is encoded once and shared by every question; -c is split across slots, so each gets half. On a GPU (CUDA or Metal), add -ngl 99; leave it off to run on the CPU.

This command accepts requests up to 16,384 tokens: -c is shared by the two slots, so each gets 16,384. For up to 131,072 tokens, set SYSTEMONE_CONTEXT=131072 and use -c 262144.

Tested on an AWS g5.2xlarge (NVIDIA A10G 24 GB, 8 vCPU AMD EPYC 7R32, 32 GiB RAM, Ubuntu 24.04, CUDA 13.2), against the Python server, every answer is the same in bf16 and Q8_0.

On an Apple M5 Pro (18-core CPU, 20-core GPU, 48 GB unified memory, macOS 26.5.2), the Q8_0 GGUF gives the same answers on Metal and on the CPU.

Run with Ollama

Use the Nace fork of Ollama with a llama-server built from the drex-v1.5 branch above. Convert the GGUF first, as in the llama.cpp steps.

git clone --branch drex-v1.5 --single-branch https://github.com/nace-ai/ollama.git && cd ollama
export OLLAMA_LLAMA_CPP_SOURCE=/path/to/llama.cpp     # your drex-v1.5 llama.cpp checkout
cmake -S llama/server --preset darwin
cmake --build build/llama-server-darwin --target llama-server --parallel 8
GOTOOLCHAIN=auto go build -trimpath -o ollama .

For CPU use the cpu preset and build/llama-server-cpu; for NVIDIA on Linux use llama_cuda_v13_linux (or llama_cuda_v12_linux) and build/llama-server-cuda_v13 (or -cuda_v12) in place of darwin and build/llama-server-darwin here and below.

Write a Modelfile next to the GGUF:

FROM ./drex-v1.5.gguf
CAPABILITY decision
PARAMETER num_ctx 16384

Start the daemon with the fork's binary, then import and call the model:

OLLAMA_HOST=127.0.0.1:11434 OLLAMA_LLAMA_SERVER=$PWD/build/llama-server-darwin/bin/llama-server ./ollama serve
OLLAMA_HOST=127.0.0.1:11434 ./ollama create drex-v1.5 -f Modelfile
curl http://127.0.0.1:11434/v1/systemone -H 'Content-Type: application/json' -d @examples/request.json

Set "model": "drex-v1.5" in the request. Tested through Ollama on the same g5.2xlarge, every answer is the same as the Python server's. Ollama starts llama-server with two slots, so the state is encoded once per request. The default is 16,384 tokens. For up to 131,072, set PARAMETER num_ctx 131072, re-import, and start the daemon with SYSTEMONE_CONTEXT=131072.

Request format

{"state": {"ticket": "I was charged twice for order A-104."},
 "questions": {"team": {"type": "choice", "instructions": "Which team handles this?",
                        "criteria": {"billing": "Charges and refunds", "shipping": "Delivery", "other": null}},
               "refund": {"type": "noul", "instructions": "Does the customer ask for a refund?"}}}

Field	What to put there
state	The document: a string, object, or list.
questions	A dictionary of named questions. The names come back as the keys of answers.

Type	You supply	You get back
choice	Named options with short descriptions. Key order is option order.	The chosen option and a probability per option
noul	A yes/no question, with optional criteria.true / criteria.false.	The probability of "yes" (0 to 1)
score	An ordered scale, lowest first.	A probability-weighted score with per-level probabilities

How scoring works

• Each question is scored in one forward pass over the state plus that question. The model reads the options and returns a probability for each one; no tokens are sampled, so the temperature, top_p and top_k values in generation_config.json do not apply.
• Requests with several questions run one pass per question.

Long documents

Requests up to 16,384 tokens are accepted by default. Set KEV_CONTEXT (maximum 131,072) to accept longer ones:

KEV_CONTEXT=131072 python serve.py --port 8000

KEV_SERVE_MAX_STATE, KEV_SERVE_MAX_BRANCH and KEV_SERVE_MAX_PACKED set the individual caps, and inference.py reads the same variables. Latency and accuracy at 8k–128k tokens are in Long-context benchmarks.

Integrations

Drex v1.5 speaks one wire format, System One (POST /v1/systemone), so anything written for that format works against it.

Where to run it

Option	What it is	Status
Python (Kev)	inference.py and serve.py from this repo; PyTorch on CUDA	Supported
Hosted Drex API	https://drex.nace.ai, bearer-key auth (nace_sk_...), see the API docs	Hosted model is drex-latest; check GET /v1/models for the current catalog
llama.cpp	drex-v1.5 branch: llama-server with /v1/systemone, GGUF (bf16 or Q8_0); CUDA, Metal and CPU	Supported
Ollama	drex-v1.5 branch of the Nace fork, same GGUF; CUDA, Metal and CPU	Supported

SDKs and clients

• TypeSafe SDK (@typesafe-ai/sdk) works against the hosted API without a fork: set TYPESAFE_BASE_URL=https://drex.nace.ai, TYPESAFE_API_KEY=nace_sk_... and TYPESAFE_DEFAULT_MODEL=drex-latest. See Migrate from TypeSafe.
• Kev-format servers and SDKs. Drex follows the System One request format also used by Kev and Jev, so clients written for those servers work unchanged against a self-hosted v1.5 server.
• Plain HTTP. Any HTTP client can call POST /v1/systemone with the JSON above.

Coding agents

The Drex agent skill makes Drex the System One decision provider for coding agents. It installs with each agent's native skill mechanism:

Agent	Install path
Claude Code	Native plugin: claude plugin install drex@nace-ai
OpenCode, Cursor, Windsurf, Cline	Link skills/drex into the agent's skills directory
Codex	$skill-installer from the GitHub directory
Hermes Agent	hermes skills install nace-ai/drex-agent-skill/skills/drex
Gemini CLI	gemini skills install ... --path skills/drex
GitHub Copilot	copilot skill add or .github/skills/drex/
OpenClaw, Pi, DeepSeek Harness	Native installer or link, per the skill README
Any Agent Skills harness	Link skills/drex into its skills directory

The skill uses the hosted API with DREX_API_KEY. To use your own server instead, add a line to the agent's instructions (for example AGENTS.md): For System One decisions, use my self-hosted Drex at http://127.0.0.1:8000. Do not fall back to hosted Drex. Self-hosted requests carry no Authorization header, and a hosted key must never be sent to your own server. See the skill README for per-agent steps.

Files

model-*.safetensors, config.json	backbone (bf16)
head.pt	pointer head
code/kev/	Kev package (Apache-2.0) that loads and scores the model
inference.py	scores one System One request
serve.py	POST /v1/systemone server
requirements.txt	Python dependencies
examples/request.json	sample request

License

Released under the Nace.AI Open RAIL-M license; see LICENSE. The Kev code in code/ is Apache-2.0.