Drex DLM

Drex DLM

Scores yes or no, multiple choice and rating questions about a document in one pass, with a probability for every option. An 8B decision model from Nace.AI that you can run yourself, under a non-commercial license.

Made by nace-ai on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: Drex DLM is a decision model from Nace.AI. You hand it a document and a set of named questions, and it returns a probability for every option of every question. Each question can ask for yes or no, offer several choices or ask for a rating, and one forward pass scores them all. Its base is Efficient-DLM-8B from NVIDIA, a diffusion language model, with a light pointer head added on top.

Who it suits: It suits developers who need structured decisions from text, such as sorting support tickets, and who want to host the model themselves.

Industry | Who uses it | How they use it | Example
Customer support | Support leads and developers | Sort tickets by team, refund request and urgency | A double-charge ticket scored for billing, refund and urgency
Back office | Operations teams | Turn documents into typed answers | Ask yes or no questions about a record
Software | Developers | Run the same API as the hosted Drex service on their own machine | Point an existing client at a local server
Research | Applied ML researchers | Study a diffusion language model with a pointer head | Compare option probabilities across questions

If you need free text written back to you, or a license that allows commercial use, you can skip it.

Where to use it: The card says it was tested on Apple M5 Max and M5 Pro machines and on an NVIDIA H100 with CUDA, and that CPU-only use is untested.

• A Mac with Apple silicon, or a machine with an NVIDIA GPU
• Python 3.12, the interpreter the card validated
• Any client that speaks the System One request format

Use case | Who | What they get back
Ticket triage | Support teams | Probabilities for the team, the refund question and urgency
Document questions | Analysts | Typed answers about a document, option by option
Local drop-in server | Developers | The same request format as the hosted API

How to set it up: You need Python 3.12, git, and roughly 16 GB of memory for the BF16 weights. Longer contexts and bigger batches need more memory.

• Python 3.12
• git, to fetch the project's repository
• About 16 GB of memory for the weights

1. Clone the project's repository from GitHub, as the card's quick start does.
2. Create a virtual environment and install the requirements.
3. Download the weights into the weights folder.
4. Run the inference script on the sample request.

cd drex-decision-models
python3.12 -m venv .venv
source .venv/bin/activate
python -m pip install -r requirements.txt
hf download nace-ai/drex-dlm --local-dir weights/drex-dlm
python inference.py --model weights/drex-dlm --request examples/request.json

How to use it: The inference script shows the model's answers to the example support ticket. To serve the model instead, start the server script, then send it requests in the same format. The server has a health endpoint that reports ok once the weights are loaded.

python serve.py --model weights/drex-dlm --port 8000

{
  "state": {
    "ticket": "I was charged twice for the same order. Please refund the extra payment."
  },
  "questions": {
    "team": {
      "type": "choice",
      "instructions": "Which team should handle this ticket?",
      "criteria": {
        "billing": "Payments, charges, and refunds",
        "technical": "Bugs and outages",
        "other": "Anything else"
      }
    },
    "refund": {
      "type": "noul",
      "instructions": "Does the customer explicitly ask for a refund?"
    }
  }
}

Tool | What it does
inference.py | Prints answers for a request file
serve.py | Starts a server on the port you choose
state field | Holds the document, as a string, object or list
questions field | Holds named questions, whose names return as keys of the answers

Example: You send the double-charge ticket with a question about which team should handle it and a yes or no question about a refund. The reply gives a probability for each team and for each refund answer.

For newcomers and experts: If you are new to this, think of it as a form that fills itself in with likelihoods. A first small step is to run the sample request from the quick start and read the printed answers.

If you know the field, the document gets bidirectional attention, and each question branch attends to the document and uses causal attention within itself. A shared pointer head turns decision and option-ending markers into queries and keys, and a scaled dot product, temperature and softmax give each question's probabilities. Larger requests are split across question rows.

Document goes in as state
Named questions branch from it
One forward pass scores them
Pointer head ranks each option
A probability per option comes out

Good to know: The card lists a Q8_0 GGUF copy, forks of llama.cpp and Ollama, and an agent skill. It reuses the System One request format, which means existing tools built for that format need no changes.

Title: Decision Index score reported on the card
Drex DLM: 52.31
Decider chat: 51.93
Jev: 51.67
AutoJev-27B: 50.94
Jebadiah 27B: 50.32
simple-jev: 50.21

• License: cc-by-nc-4.0, which allows non-commercial use only
• Cost to run: no API key or paid service is named, and the BF16 weights are about 16 GB
• Data it reaches: the download comes from Hugging Face and GitHub, and a self-run server works on your own machine
• Not for: commercial use, or CPU-only runs, which the card says it has not tested

On Hugging Face, 13 November 2026

• Task: text classification
• Library: transformers
• Parameters: 8.2B
• Weights: about 16.4 GB in BF16; about 4.1 GB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 177
• Likes: 25
• License: cc-by-nc-4.0
• Based on: nvidia/Efficient-DLM-8B
• Quantized versions: 1
• Tags: transformers, safetensors, edlm, feature-extraction, decision-model, system-one, typed-decisions, decision-index, classification, calibrated-probabilities, decisionbench, zero-shot

Links

• Model: https://huggingface.co/nace-ai/drex-dlm
• Files: https://huggingface.co/nace-ai/drex-dlm/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download nace-ai/drex-dlm

Then follow the usage in its model card. Nothing in this kit runs by itself.