REAX 1.3

REAX 1.3

Returns probabilities for the options of a decision request by running two models side by side on one GPU and averaging them. For teams that want an open decision model behind a Jev-compatible interface.

Made by decisionmodels 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: REAX 1.3 comes from decisionmodels, a decentralised group working on Bittensor subnet 92. Miners there compete openly to train decision models, and the group builds its releases from the best entries. This one pairs two models that run in parallel on one GPU. Each gives a probability for every option of a request, and the two results are averaged equally.

Who it suits: It suits teams that want automatic decisions with probabilities, and that can run Docker on a Linux machine with a large NVIDIA GPU.

Industry | Who uses it | How they use it | Example
Customer support | Support engineers | Send a complaint to the right team | Choosing between delivery support and billing support
Operations | Automation developers | Add a decision step with probabilities to a workflow | Branching on the most likely option
AI research | Researchers | Study models that came out of an open training competition | Comparing it with other decision models
Platform engineering | Infrastructure teams | Serve a decision model from local files only | Running the service on a private GPU machine

You can skip it if you have no NVIDIA RTX PRO 6000 class GPU with 96 GB, since the setup is built around that card.

Where to use it:

• A Linux machine whose GPU is NVIDIA's RTX PRO 6000 (Blackwell, 96 GB)
• Docker with the NVIDIA Container Toolkit
• Your own software, calling a local HTTP service
• The Decision Index kit, if you want to score it offline

Use case | Who | What they get back
Typed decision request | Developers | A probability for every option you supply
Health check | Operators | A reply that shows the server is running
Benchmark run | Researchers | Scores from the Decision Index kit instead of HTTP

How to set it up: You need a Linux machine with a 96 GB NVIDIA GPU, Docker, plenty of disk and enough memory to load the weights.

• Linux with one GPU of NVIDIA's RTX PRO 6000 type (Blackwell, 96 GB) and a driver that supports CUDA 13
• Docker with the NVIDIA Container Toolkit
• At least 400 GB of free disk and 64 GiB of RAM, with 128 GiB recommended while the weights load
• About 115 GB for the downloaded weights of both parts

1. Clone the REAX Engine repository and the Decision Index kit, and check out the commits the card names.
2. Build the two Docker images from the reax13 folder.
3. Download both parts of the weights with the Hugging Face tool.
4. Start the server with the docker run command from the card, which serves local files only.

cd reax-engine/reax13
docker build -t reax13-base -f Dockerfile .
docker build -t reax13-runtime -f Dockerfile.conv .

python3 -m venv .hf-cli
source .hf-cli/bin/activate
pip install -U "huggingface_hub[cli]"
hf download decisionmodels/REAX-1.3 --include 'part-g/*' --include 'part-q/*' --local-dir model-repo

How to use it: Once the server is up, you send a JSON request to its local systemone path on port 8080. The first answer takes a few minutes, since the model must load and warm up. The request holds a state and typed questions.

{"state":"A parcel arrived late.","questions":{"route":{"type":"choice","instructions":"Which team should handle the complaint?","criteria":{"delivery":"Delivery support","billing":"Billing support"}}}}

Tool | What it does
GET /healthz | Health check for the running server
POST /v1/systemone | Takes a state and typed questions and returns probabilities per option

Example: You send a note that a parcel arrived late, with one question asking whether delivery or billing support should handle the complaint. The reply gives a probability for the delivery option and one for the billing option.

For newcomers and experts: If you are new to this, think of two judges who each score every option, with the final answer being the average of their scores. A first small try is to start the server and send the example request above.

For people who know the field, one part comes from miner uid 18 on a Gemma line and the other from miner uid 83 on a Qwen3.5-27B line, each blended with another model. Both load in FP8 on one GPU, using about 88.5 GiB at peak. Any request over 32,000 input tokens is turned away rather than cut down, and slow long requests call for a client timeout of 1,800 s or more.

Your request arrives with a state and questions
Part G and Part Q each score every option
The two probability sets are averaged equally
You get a probability for every option

Good to know: The card's own measurement is 73.71 on the public Decision Index 0.3 suite. The authors call it internal and not an official leaderboard score. Jev-compatible describes the interface only and does not mean endorsement or identical outputs.

• License: Apache 2.0, and the REAX Engine it runs on is MIT licensed
• Cost to run: one 96 GB NVIDIA GPU machine, with no paid service named
• Data it reaches: the requests you send, with the server started to use local files only
• Not for: machines without the specified 96 GB GPU, or requests above 32,000 input tokens

On Hugging Face, 13 November 2026

• Formats: Safetensors
• Downloads in the last 30 days: 0
• Likes: 11
• License: apache-2.0
• Languages: en
• Fine-tunes: 2
• Tags: safetensors, decision-model, reax

Links

• Model: https://huggingface.co/decisionmodels/REAX-1.3
• Files: https://huggingface.co/decisionmodels/REAX-1.3/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download decisionmodels/REAX-1.3

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