THX-02: a 4.5B open decision model that beats 27B models — and the API is free

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.

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

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

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.

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:

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.

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

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:

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

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.

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.

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.

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

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.

pip install thx02 pip install "thx02[server]" We can't wait to see what you decide with it.

HAL-X, Baku