---
title: "THX-02 by HAL-X-AI"
kind: "Kit"
category: "Developer"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/dda0a2fd-6c9e-4f2c-b1f5-0e6c8f48d25a"
updated: "2026-11-12"
---

# THX-02 by HAL-X-AI

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

Answers plain-language questions about a message, document, image or chart with a probability for every option, in tens of milliseconds. For developers who route tickets and sort records.

THX-02 by HAL-X-AI is a kit in the Developer category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-12. Download it on this page, a zip of its files. Nothing in it runs by itself.

Made by HAL-X-AI

## About

### What it is

THX-02 is a decision model from HAL-X-AI. You hand it a piece of content, such as a message, ticket, document, JSON record, agent trace, photo or chart, plus typed questions in plain language. It answers each question with a probability for every option. When it is unsure, it can write a short thought first and then decide.

### Who it suits

It suits developers and teams who need fast, calibrated answers to fixed questions about incoming content, without retraining for each new task.

| Industry | Who uses it | How they use it | Example |
| --- | --- | --- | --- |
| Customer support | Support engineers | Route tickets and flag refund requests | Decide which team gets a message and whether it asks for a refund |
| Manufacturing | Quality teams | Grade items from camera frames | Mark each egg on a line as clean, dirty or cracked |
| Finance | Analysts | Read charts and documents against set questions | Ask in which year a rate dipped lowest on a chart |
| Agent builders | Developers | Check an agent trace against yes or no questions | Did the agent finish the task it was given |

If you need free-form writing rather than a choice among options, you can skip it.

### Where to use it

- Python, through the thx02 package and its client
- A command line, through the thx02 command
- The HAL-X hosted API, or your own server
- Your own computer, on a GPU or a CPU
- Phones, since the client has no dependencies and works in Termux on Android

| Use case | Who | What they get back |
| --- | --- | --- |
| Ticket routing | Support teams | A team choice with a probability for each team |
| Yes or no checks | Developers | A probability that the answer is yes |
| Scoring on a scale | Analysts | A placement on an ordered scale such as calm, annoyed or angry |

### How to set it up

You need these first:

- Python and pip
- Optionally a HAL-X API key, since the free tier of the hosted API is limited per IP
- A GPU or CPU, if you run the model yourself

1. Install the thx02 package, which is the client and the command.
2. Set your API key if you have one.
3. To run the model yourself, install the local extra, or download the repository and its requirements.

```bash
pip install thx02                          # API client + the thx02 command
export HALX_API_KEY=sk-...                 # HAL-X API key (optional on the free tier, which is limited per IP)
```

```bash
pip install "thx02[local]"                 # then: from thx02 import THX02; THX02.load("HAL-X-AI/THX-02")
```

```bash
hf download HAL-X-AI/THX-02 --local-dir THX-02 && cd THX-02
pip install -r requirements.txt            # add requirements-fast.txt for the compiled GPU path
```

### How to use it

Give the model a state and a set of typed questions, and it returns an answer and probabilities for each question. The command line takes the message and its questions as options.

```bash
thx02 "Salam, kartimdan iki defe pul cixilib" --choice "team=billing:charges and refunds,support:technical problems" \
      --yesno "Does the customer ask for a refund?"
```

| Tool | What it does |
| --- | --- |
| choice | Picks one option from a list of up to 255 |
| noul | Answers a yes or no question with a probability |
| score | Places the answer on an ordered scale |
| decide | The Python call that takes a state and its questions |
| think | Lets the model write a short thought first when it is unsure |

### Example

A customer writes "I was charged twice." You ask which team should handle it, billing or shipping, and whether the customer wants a refund. The model returns a probability for each team and a probability for the refund question.

### For newcomers and experts

Instead of writing text, the model picks from the options you give it, and tells you how sure it is. A good first step is to try the command line with one short message and two questions.

The model never invents an option and makes no free text unless it thinks. It is a 4.5B decision model plus a 60M think adapter, trained for requests up to 32k tokens, with BF16 on a GPU and BF16 or FP32 on a CPU.

You send a state and typed questions → The model scores every option → It may write a short thought if unsure → You get answers with probabilities

### Good to know

Scores come from the authors' own tests, and speed was measured on named GPUs.

Score on the Decision Index 0.3 public index

| Label | Value |
| --- | --- |
| THX-01 | 11.30 |
| THX-02 without thinking | 63.83 |
| THX-02 with thinking | 65.06 |

- Speed: on one RTX PRO 6000 a request takes a median of 50 ms, or 79 ms when the model thinks, and one RTX 4090 serves 129 requests per second
- Inputs: text, images and charts in one request, with up to 4 images
- Languages: post-training covered over 20 languages, for both training and evaluation
- License: Apache 2.0
- Cost to run: the hosted API has an optional key and a free tier limited per IP, and no price is named
- Data it reaches: the default client talks to the HAL-X hosted API, so your content goes there unless you run the model yourself

## README

````markdown
# THX-02 by HAL-X-AI

Answers plain-language questions about a message, document, image or chart with a probability for every option, in tens of milliseconds. For developers who route tickets and sort records.

Made by HAL-X-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: THX-02 is a decision model from HAL-X-AI. You hand it a piece of content, such as a message, ticket, document, JSON record, agent trace, photo or chart, plus typed questions in plain language. It answers each question with a probability for every option. When it is unsure, it can write a short thought first and then decide.

Who it suits: It suits developers and teams who need fast, calibrated answers to fixed questions about incoming content, without retraining for each new task.

```table
Industry | Who uses it | How they use it | Example
Customer support | Support engineers | Route tickets and flag refund requests | Decide which team gets a message and whether it asks for a refund
Manufacturing | Quality teams | Grade items from camera frames | Mark each egg on a line as clean, dirty or cracked
Finance | Analysts | Read charts and documents against set questions | Ask in which year a rate dipped lowest on a chart
Agent builders | Developers | Check an agent trace against yes or no questions | Did the agent finish the task it was given
```

If you need free-form writing rather than a choice among options, you can skip it.

Where to use it:

- Python, through the thx02 package and its client
- A command line, through the thx02 command
- The HAL-X hosted API, or your own server
- Your own computer, on a GPU or a CPU
- Phones, since the client has no dependencies and works in Termux on Android

```table
Use case | Who | What they get back
Ticket routing | Support teams | A team choice with a probability for each team
Yes or no checks | Developers | A probability that the answer is yes
Scoring on a scale | Analysts | A placement on an ordered scale such as calm, annoyed or angry
```

How to set it up: You need these first:

- Python and pip
- Optionally a HAL-X API key, since the free tier of the hosted API is limited per IP
- A GPU or CPU, if you run the model yourself

1. Install the thx02 package, which is the client and the command.
2. Set your API key if you have one.
3. To run the model yourself, install the local extra, or download the repository and its requirements.

```bash
pip install thx02                          # API client + the thx02 command
export HALX_API_KEY=sk-...                 # HAL-X API key (optional on the free tier, which is limited per IP)
```

```bash
pip install "thx02[local]"                 # then: from thx02 import THX02; THX02.load("HAL-X-AI/THX-02")
```

```bash
hf download HAL-X-AI/THX-02 --local-dir THX-02 && cd THX-02
pip install -r requirements.txt            # add requirements-fast.txt for the compiled GPU path
```

How to use it: Give the model a state and a set of typed questions, and it returns an answer and probabilities for each question. The command line takes the message and its questions as options.

```bash
thx02 "Salam, kartimdan iki defe pul cixilib" --choice "team=billing:charges and refunds,support:technical problems" \
      --yesno "Does the customer ask for a refund?"
```

```table
Tool | What it does
choice | Picks one option from a list of up to 255
noul | Answers a yes or no question with a probability
score | Places the answer on an ordered scale
decide | The Python call that takes a state and its questions
think | Lets the model write a short thought first when it is unsure
```

Example: A customer writes "I was charged twice." You ask which team should handle it, billing or shipping, and whether the customer wants a refund. The model returns a probability for each team and a probability for the refund question.

For newcomers and experts: Instead of writing text, the model picks from the options you give it, and tells you how sure it is. A good first step is to try the command line with one short message and two questions.

The model never invents an option and makes no free text unless it thinks. It is a 4.5B decision model plus a 60M think adapter, trained for requests up to 32k tokens, with BF16 on a GPU and BF16 or FP32 on a CPU.

```flow
You send a state and typed questions
The model scores every option
It may write a short thought if unsure
You get answers with probabilities
```

Good to know: Scores come from the authors' own tests, and speed was measured on named GPUs.

```chart
Title: Score on the Decision Index 0.3 public index
THX-01: 11.30
THX-02 without thinking: 63.83
THX-02 with thinking: 65.06
```

- Speed: on one RTX PRO 6000 a request takes a median of 50 ms, or 79 ms when the model thinks, and one RTX 4090 serves 129 requests per second
- Inputs: text, images and charts in one request, with up to 4 images
- Languages: post-training covered over 20 languages, for both training and evaluation
- License: Apache 2.0
- Cost to run: the hosted API has an optional key and a free tier limited per IP, and no price is named
- Data it reaches: the default client talks to the HAL-X hosted API, so your content goes there unless you run the model yourself

## On Hugging Face, 13 November 2026

- Task: zero shot classification
- Library: thx02
- Parameters: 4.5B
- Weights: about 9.1 GB in BF16; about 2.3 GB at 4-bit (estimate)
- Formats: Safetensors
- Downloads in the last 30 days: 6,598
- Likes: 54
- License: apache-2.0
- Languages: en, az, zh, kk, uz, ky, ja, es
- Tags: thx02, safetensors, decision-model, classification, routing, multimodal, thinking, calibrated-probabilities, zero-shot-classification

## Links

- Model: https://huggingface.co/HAL-X-AI/THX-02
- Files: https://huggingface.co/HAL-X-AI/THX-02/tree/main

## Get the model

Download its files with Hugging Face's command line:

```sh
pip install -U huggingface_hub
hf download HAL-X-AI/THX-02
```

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

## What is in it

1 files, 6 KB, downloaded as a zip.

```text
README.md  6 KB
```

## Source

[HAL-X-AI/THX-02 on Hugging Face](https://huggingface.co/HAL-X-AI/THX-02)

## 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 |
| --- | --- | --- | --- | --- | --- |
| THX-02 by HAL-X-AI (this page) | 6,598 | 54 | 4.5B | apache-2.0 | 2026-11-04 |
| [Seb-9B-v2](https://mindket.com/p/fb7adb4a-f993-4988-8461-04d33be95e03) | 265 | 4 | 9.7B | apache-2.0 | 2026-11-10 |
| [OpenJev](https://mindket.com/p/173f3b2e-f55d-4777-9609-91685a1f0a12) | 9,293 | 199 | 27.4B | cc-by-nc-4.0 | 2026-10-09 |
| [elephant-1](https://mindket.com/p/ae806c31-0f69-4485-8475-443c9347b0a8) | 7,426 | 115 | 9.4B | mit | 2026-10-22 |
| [mammoth-1](https://mindket.com/p/72aafbd9-0774-437a-9492-f659f9a2a186) | 5,903 | 97 | 27.4B | mit | 2026-10-22 |
| [joey-1](https://mindket.com/p/1e3f2aa5-2042-45ae-a466-48b620b003f1) | 1,539 | 47 | 2.7B | mit | 2026-10-29 |

Numbers as Mindket last read them, from 2026-11-12 to 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-11-04
- First published: 2026-10-23
- Checked on Hugging Face: 2026-11-12
- Something wrong? Tell us: https://mindket.com/takedown#ask

## Get it

- [Open HAL-X-AI/THX-02 on Hugging Face](https://huggingface.co/HAL-X-AI/THX-02)
- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/dda0a2fd-6c9e-4f2c-b1f5-0e6c8f48d25a)
- [Its page on Mindket](https://mindket.com/p/dda0a2fd-6c9e-4f2c-b1f5-0e6c8f48d25a)
