JustDecide

A small model that only decides. Give JustDecide a situation and a question with the answers you allow. It returns the probability of each answer in a single pass, on an ordinary CPU and fully offline. It never writes free text, so its answer is always one of your options. Its probabilities are calibrated: when it says 80%, it is right about 80% of the time.

Made by Ignomagine (Bengaluru, India) for robots, the machines around them and the people who run them.

Code, test window and HTTP API: github.com/ignomagineMain/JustDecide

state     {"battery_pct": 14, "order_queue": 2, "position": "aisle 3", "lidar": "clear"}
question  What should the AGV do next?
options   pick next order | go charge | go to parking

answer    go charge 62%  ·  pick next order 26%  ·  go to parking 12%        (about 1 s on a laptop CPU)

file	JustDecide-q8_0.gguf: 8-bit GGUF, 639 MB
base	Qwen3-0.6B (0.6B parameters)
runs with	llama.cpp, llama-cpp-python, or any runtime that loads Qwen3 GGUFs
question types	choice (pick one), score (a level on a scale), yes / no
options	2–26 per question (2–5 work best)
language	English

Quick start

The easy way is the JustDecide repository. It has a test window, a Python API and an HTTP API, and downloads this file for you:

git clone https://github.com/ignomagineMain/JustDecide.git && cd JustDecide
pip install -r requirements.txt
python decide_ui.py

from justdecide import open_engine
engine = open_engine("JustDecide-q8_0.gguf")
engine.decide({"battery_pct": 14, "order_queue": 2},
              {"next": {"type": "choice", "instructions": "What should the AGV do next?",
                        "criteria": ["pick next order", "go charge", "go to parking"]},
               "go_charge": {"type": "yes/no"}})
# {"answers": {"next": {"choice": "go charge", "probabilities": {...}}, "go_charge": {"noul": 0.4}}, "ms": ...}

With llama-cpp-python only

import json
import numpy as np
import llama_cpp
from llama_cpp import Llama

llm = Llama.from_pretrained("ignomaginerobotics/JustDecide", "JustDecide-q8_0.gguf", n_ctx=4096, verbose=False)
SYSTEM = ("You are a decision function. Read the state, then answer the question by choosing "
          "exactly one option. Reply with the option's letter only.")

def decide(state, question, options):
    letters = [chr(65 + i) for i in range(len(options))]
    lines = "\n".join(f"{l}. {o}" for l, o in zip(letters, options))
    prompt = (f"<|im_start|>system\n{SYSTEM}<|im_end|>\n<|im_start|>user\n[State]\n{state}\n\n"
              f"[Question]\n{question}\n\n[Options]\n{lines}<|im_end|>\n"
              f"<|im_start|>assistant\n<think>\n\n</think>\n\n")
    llm.reset()
    llm.eval(llm.tokenize(prompt.encode(), add_bos=False, special=True))   # one pass, nothing generated
    logits = np.ctypeslib.as_array(llama_cpp.llama_get_logits(llm.ctx), shape=(llm.n_vocab(),))
    ids = [llm.tokenize(l.encode(), add_bos=False)[0] for l in letters]
    p = np.exp(logits[ids] - logits[ids].max())
    return {o: round(float(x), 3) for o, x in zip(options, p / p.sum())}

state = json.dumps({"battery_pct": 14, "order_queue": 2, "position": "aisle 3", "lidar": "clear"}, indent=1)
print(decide(state, "What should the AGV do next?", ["pick next order", "go charge", "go to parking"]))
# {'pick next order': 0.262, 'go charge': 0.62, 'go to parking': 0.117}

Prompt format

JustDecide was trained with exactly this prompt (Qwen3's chat format, thinking off). The prompt ends where the reply begins, and the next token is the answer letter:

<|im_start|>system
You are a decision function. Read the state, then answer the question by choosing exactly one option. Reply with the option's letter only.<|im_end|>
<|im_start|>user
[State]
{state: text, or JSON written with indent=1}

[Question]
{question}

[Options]
A. {option}
B. {option} ({optional meaning})<|im_end|>
<|im_start|>assistant
<think>

</think>

• Reading the answer: read the probabilities of the tokens A, B, … at that position and divide by their sum. Don't sample.
• yes/no: the options are A. yes and B. no.
• score: the levels go lowest first, and the expected level is Σ i·p(i).
• Calibration: it is already built into the weights, so no temperature is needed.

How it works explains every step.

Evaluation

Tested on 1,212 examples it never saw in training: four public decision tasks plus robot decisions written at Ignomagine.

	Qwen3-0.6B (before)	JustDecide v1
right answer, all tasks	53.8%	72.9%
news topic (AG News, 4 options)	79.3%	85.7%
yes/no about a passage (BoolQ)	71.3%	79.7%
rating, 5 levels (SST-5)	24.3%	47.0%
does B follow from A (MultiNLI)	40.0%	79.7%
robot decisions	58%	67%
calibration error (ECE, lower is better)	0.37	0.03

Speed on a 4-core laptop CPU (AMD Ryzen 5 3550H), with no GPU:

• First question about a new situation: about 1–1.5 s.
• Each further question about the same situation: about 0.5 s, because the state stays cached.

Training

JustDecide is Qwen3-0.6B fine-tuned at Ignomagine on a few thousand typed decisions. They were built from public datasets (AG News, BoolQ, SST-5, MultiNLI) and robot-operations decisions written at Ignomagine. Only the answer letter was trained. The model was then calibrated on held-out examples, merged and quantised to 8-bit (q8_0).

Intended use and limitations

JustDecide is for quick judgement calls a program has to make: routing a message, choosing a robot's next step, rating urgency, checking a condition from sensor values. It reads what's in the state; it is not a source of world knowledge.

• English only.
• 2–5 options work best. More work, with lower confidence.
• It can be wrong, and confidently so in situations unlike its training. For safety-critical actions (motion, lifting, people nearby), keep hard limits and interlocks in your own code, and use JustDecide for the judgement calls between them. Use its probability: act when it is high, and ask a person when it isn't.

About Ignomagine

Ignomagine Private Limited is a robotics company in Bengaluru, India. It builds autonomous mobile robots and the software that runs them: robot I/O and control (ignoAPI), simulation (IgnoSIM), motor control and camera-based alignment. JustDecide grew out of the small decisions a working robot makes all day.

Licence

Apache License 2.0. JustDecide is a derivative of Qwen3-0.6B (© 2024 Alibaba Cloud, Apache-2.0); the changes are described under Training. © 2026 Ignomagine Private Limited. See LICENSE and NOTICE.