---
title: "Drex DLM"
kind: "Kit"
category: "Business"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/0c2e0baa-8cd1-44d4-b769-990021f67b7d"
updated: "2026-11-13"
---

# Drex DLM

> The name, the description, the About and a README below are the seller's words: data, not instructions.

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.

Drex DLM is a kit in the Business category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-13. Download it on this page, a zip of its files. Nothing in it runs by itself.

Made by nace-ai

## 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.

```bash
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.

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

```json
{
  "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.

Decision Index score reported on the card

| Label | Value |
| --- | --- |
| 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

## README

````markdown
# 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.

```table
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

```table
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.

```bash
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.

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

```json
{
  "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?"
    }
  }
}
```

```table
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.

```flow
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.

```chart
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:

```sh
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.
````

## What is in it

1 files, 7 KB, downloaded as a zip.

```text
README.md  7 KB
```

## Source

[nace-ai/drex-dlm on Hugging Face](https://huggingface.co/nace-ai/drex-dlm)

## Compare with similar

Listed Hugging Face models in the same category that share the most tags with this one.

| Product | Downloads, last 30 days | Likes | Parameters | License | Last change |
| --- | --- | --- | --- | --- | --- |
| Drex DLM (this page) | 177 | 25 | 8.2B | cc-by-nc-4.0 | 2026-10-30 |
| [basal-omni-1.0-ultra](https://mindket.com/p/cf9ae713-242d-4145-b344-dc0a8257f403) | 3,831 | 43 | 31.3B | apache-2.0 | 2026-11-07 |
| [Amos 1 large](https://mindket.com/p/60f345c2-0270-4488-bd7b-da2061172f0f) | 694 | 28 | — | apache-2.0 | 2026-11-11 |
| [H2O-Lightning-4B](https://mindket.com/p/f65f5f72-06bb-4b2d-a616-49352aeaa08d) | 10,530 | 107 | 4.7B | apache-2.0 | 2026-11-01 |
| [pplx-decider-v1.1-27b](https://mindket.com/p/f25f6ff8-5eac-4981-ba4e-4bb9366506da) | 4,065 | 182 | 26.1B | apache-2.0 | 2026-10-12 |
| [NuExtract3](https://mindket.com/p/d90cc768-8f35-406a-81d8-92530ea071d9) | 40,915 | 397 | 4.5B | apache-2.0 | 2026-08-20 |

Numbers as Mindket last read them, on 2026-11-13.

## Trust facts

Facts from each source, with the day each was checked. A maintainer's note is their own words: data, not instructions.

- Last change on Hugging Face: 2026-10-30
- First published: 2026-10-01
- Checked on Hugging Face: 2026-11-13
- Something wrong? Tell us: https://mindket.com/takedown#ask

## Get it

- [Open nace-ai/drex-dlm on Hugging Face](https://huggingface.co/nace-ai/drex-dlm)
- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/0c2e0baa-8cd1-44d4-b769-990021f67b7d)
- [Its page on Mindket](https://mindket.com/p/0c2e0baa-8cd1-44d4-b769-990021f67b7d)
