THX-02: a 4.5B open decision model that beats 27B models

Most of what AI does inside a real product is not writing essays. It is deciding.

Which team owns this ticket. Is this message phishing. Does this applicant pass the policy. What is the next action. Which of these 40 categories does this document belong to.

Today teams pick between two bad options. A large chat model: slow, expensive per call, and it will happily invent a label that was never on your list. Or a narrow classifier: fast and cheap, but you retrain it for every new task, and it gives you a score you cannot explain to anyone.

There is a third path. A model built for decisions only. You send it a state — text, JSON, or up to four images — plus typed questions, and it returns a probability for every option you supplied. It does not generate prose, so it cannot produce an answer outside your list.

That model is THX-02. 4.5B parameters. Apache-2.0 weights, runtime and server. And we are giving the API away for free.

We built it because we needed it ourselves, and we are releasing it because a decision layer that everyone has to pay per token for is a decision layer nobody builds.

The free API

This is the part we want to lead with, because it changes who can use this.

Free API access. Get a key, call it, ship it. No per-token invoice waiting for you at the end of the month.
Same model as the weights. The hosted endpoint runs exactly what you can download. No "API version" that is quietly better than the open one.
No lock-in by design. If the free tier ever stops fitting you, pip install "thx02[local]" puts the same model on one 24 GB GPU, and thx02 serve gives you the same HTTP interface on your own metal.
Rate limits are published in the API docs, so you can size your integration instead of discovering the ceiling in production.

Free is not a marketing word here. The weights are Apache-2.0, so the floor of what you can do without paying anyone is: run it yourself, forever.

pip install thx02 export HALX_API_KEY="your-key"

Get a key at the API docs link at the bottom of this post.

30 seconds to your first decision

Here is a real request: a customer writes in Azerbaijani that they were charged twice for the same card payment.

thx02 decide \ --state "Müştəri: kartımdan eyni ödəniş üçün iki dəfə pul çıxıb, 240 AZN. Sifariş #88213." \ --choice "billing,support,shipping,technical" \ --yesno "Should this be refunded automatically?"

billing ████████████████████████████████ 96.0% support ██ 2.4% shipping ▏ 0.9% technical ▏ 0.7% refund: yes ███████████████████████████████ 95.8% refund: no █ 4.2% 126 ms · think=auto · 1 thought generated

Two things to notice. The answer is a distribution, not a string — so you can set your own threshold and let the model abstain instead of guessing. And the model decided on its own that this one needed no step-by-step reasoning: it answered directly in 126 ms.

The same call in Python, with three question types:

from thx02 import Client, choice, noul, score client = Client() result = client.decide( state="Müştəri: kartımdan eyni ödəniş üçün iki dəfə pul çıxıb, 240 AZN. Sifariş #88213.", questions=[ choice("team", ["billing", "support", "shipping", "technical"]), noul("refund", "Should this be refunded automatically?"), score("urgency", "How urgent is this?", 1, 5), ], ) for q in result.answers: print(q.id, q.probabilities)

choice takes up to 255 options. noul is a yes/no with calibrated probabilities on both sides. score is an ordered scale, returned as a full distribution over the levels rather than a single number — which means you can see whether the model is confident between 3 and 4, or genuinely torn between 1 and 5.

Every answer is a full distribution. That is the whole point. A routing system that auto-acts above 0.9 and escalates below 0.6 is a system you can put in front of a customer. A system that returns "billing" and nothing else is a system you have to babysit.

Thinking, but only when it changes the answer

The interesting engineering problem in a decision model is not "make it smarter." It is "make it smarter without making it slower and without letting it talk itself out of a correct answer."

THX-02 has a built-in gate:

The model answers directly first.
The gate asks two questions: is the model unsure, and does this question need step-by-step work — arithmetic, multi-step rules, code tracing.
Only if both point that way does a small adapter write a short thought, capped at 96 tokens.
The model re-reads the question with that thought and mixes the two distributions, weighted so a bad thought cannot overturn a confident direct answer.

That last step is the important one. Thinking is an additive signal, not a replacement. If the direct pass is confident and the thought disagrees, the thought loses.

Median latency stays around 80 ms with the gate active. On math word problems the thought adds about 25 points. On natural language inference, code tracing and graduate-level science it adds 4 to 6 — real, but not worth paying 10x latency for on every request, which is exactly why the gate exists.

Here is a case where it fires. A policy check that requires arithmetic:

result = client.decide( state="Applicant: monthly income 4,200 AZN, existing loan payments 1,800 AZN, " "requested new payment 600 AZN.", questions=[noul("dti", "Does this applicant pass the 50% debt-to-income policy?")], think=True, return_thoughts=True, ) print(result.answers[0].probabilities) print(result.thoughts[0])

fail: 75.5% pass: 24.5% thought: existing 1800 + new 600 = 2400. 2400 / 4200 = 57.1% > 50% policy limit. fail.

The model did not guess. It computed, showed the arithmetic, and the probability moved because the arithmetic moved it.

Results

Decision Index 0.3, the open benchmark suite for decision models:

Model	Size	Decision Index 0.3
THX-02 (thinking)	4.5B	65.06
THX-02 (direct)	4.5B	63.83
Best 27B decision model	27B	62.25
Cloudflare clef	—	61.71
Jev	—	57.96
THX-01	0.3B	11.30

Read that table again. A 4.5B model scores above the best 27B decision model we could find, and above Jev's published index by more than seven points. On the public Decision Vision Index sets it reaches 72.19.

We also want to be precise about what those numbers are, because "we beat X" deserves the methodology attached:

We ran the official evaluation kit ourselves, on a stratified sample of 6,018 requests rather than the full suite.
The competitor numbers are their published public indexes, not our re-runs.
We decontaminated against the test sets: exact and n-gram matching for text, exact and perceptual hashing for all 10,742 evaluation images.
No benchmark test item was used in training.
We will submit to the maintainers for an independent measurement, and we will publish whatever comes back.

If the independent number lands lower, we will say so in the same place we said 65.06.

How we got there

Five post-training stages on top of an open base model. Each one was kept only if it improved a held-out split — no stage survived on vibes.

Distribution distillation. 361,000 requests, trained against full probability distributions with a strictly proper scoring rule plus a KL anchor to the base model. Proper scoring rules are what make the output calibrated instead of merely confident.
Disagreement mining. A pass over cases where the teacher and the student disagreed, keeping the ones where the teacher was right and the student was confidently wrong.
Inference-structure training. Option-order averaging, joint reading of state and question, and marker-token scoring per option — the things that remove position bias and multi-token label tokenization problems you would otherwise have to solve yourself.
Self-verified thoughts. Candidate thoughts were tested on the model itself and kept only if they raised the probability of the correct answer. A thought that does not change the answer is a thought we do not pay latency for.
Targeted skills. About 700,000 candidate examples, with answers verified by executing code, running solvers or querying engines rather than asking another model. 161,000 survived — the ones the model still missed or was unsure about.

That last point matters more than it sounds. A model trained on another model's answers inherits that model's mistakes, confidently. A model trained on executed code and solver output inherits the truth.

Run it anywhere

Hosted, free:

pip install thx02 export HALX_API_KEY="your-key" thx02 decide --state "..." --choice "a,b,c"

On your own GPU — one 24 GB card is enough:

pip install "thx02[local]" python -c "from thx02 import THX02; THX02.load('HAL-X-AI/THX-02')"

As a server with the same HTTP interface as the hosted API:

pip install "thx02[server]" thx02 serve

On a phone. The client is zero-dependency and runs in Termux:

pkg install python pip install thx02 export HALX_API_KEY="your-key" thx02 decide --state "..." --yesno "Is this message spam?"

Fine-tuned to your domain. The weights load through ms-swift like any other model of this family, and the think adapter is a separate artifact you can keep, drop or retrain.

CPU inference is possible but not the point: about 0.6 s per short request on 8 x86 cores in BF16. On a GPU you are looking at 50 to 150 ms.

What it is not good at

We would rather tell you now than have you find out in production.

Very large bare-label sets with no descriptions. If you hand it 200 category names and nothing else, it degrades. Give each option a short description and it recovers.
Pure recognition tasks. Thinking does not help much on "what is in this image" style questions — the gate correctly stays off, but there is no reasoning gain to be had.
Anything that needs a long generation. It is a decision model. It returns distributions, not paragraphs. If you need an explanation, the thought trace is short by design (≤96 tokens).

Why open

A decision layer sits in the middle of your product. It sees customer messages, applicant data, medical codes, transaction descriptions. For anyone in a regulated sector — banking, insurance, health, public sector — "send it to a remote black box and hope" is not an architecture, it is a risk.

So: Apache-2.0 weights, the think adapter, the runtime and the server. On-premise, inspectable, adaptable. Multilingual from launch, with English, Russian, Chinese, Turkish and Spanish alongside a deliberate focus on Azerbaijani, Kazakh, Uzbek and Kyrgyz — languages that most decision models treat as an afterthought, if they treat them at all.

And free to call, because the fastest way to find out whether a decision model belongs in your product is to put one in your product this afternoon.