Nirṇaya

An open, India-first System-One decision model. Given a state and typed questions, it returns calibrated probability distributions in one forward pass, with no text generation.

The Problem

A lot of enterprise AI in India ends with picking one option, one urgency level, or one yes/no. Ticket routing, UPI complaint triage, escalation gating, script detection. The downstream code wants a probability, not a paragraph.

General-purpose LLMs handle these as generation tasks: prompt the model, parse the JSON, hope it parses. Response times run to a second or two per call, cost scales with tokens, and calibration is whatever falls out.

Nirṇaya works differently. It reads the state once, and typed heads on top of the backbone emit probability distributions directly, one per question, all in the same forward pass.

Three Kinds of Questions

Every request to Nirṇaya is a (state, questions) pair. The state is arbitrary text, often Hindi, Hinglish, or one of five other Indic languages. Each question is one of three typed shapes:

A single message can carry more than one question: intent and urgency and escalation share the same backbone pass.

What’s Inside

• Backbone: Qwen3-4B, a compact open-weights language model, fine-tuned with a small adapter for decision tasks.
• Decision heads: two lightweight heads on top of the backbone. One ranks options for choice and score questions; the other answers noul (yes/no) questions.
• Languages: English, Hindi, Bengali, Tamil, Telugu, Kannada, Malayalam, and Hinglish.

Architecture

Every request goes through the backbone once. The typed heads read a handful of hidden states from that single pass and produce all the probabilities.

Input formatting

A (state, questions) request is serialised into a plain-text sequence, one row per question:

[STATE]
{state}
[QUESTION]
{instructions}
[OPTIONS]
(1) {opt_1}
(2) {opt_2}
...
[ANSWER]

Segments are tokenised separately so the exact token positions of two kinds of anchors are known:

• Decision anchor: the last token of the [ANSWER] marker.
• Option anchors: the last token of each option line (choice and score only).

For noul questions the [OPTIONS] block is dropped, and only the decision anchor is used.

Backbone

Qwen3-4B reads the whole sequence in a single forward pass and produces one hidden vector per token. From here the heads only touch the anchor vectors identified above; there is no autoregressive decoding.

PointerHead (choice and score)

The decision anchor becomes a query vector. Each option anchor becomes a key vector. The head scores every option by the query-key inner product, applies a softmax over the valid options, and returns a probability per option that sums to 1.

For score questions, where the options are ordered levels (e.g. urgency 1-5), it also reports the expected level alongside the full distribution.

NoulHead (yes/no)

Binary questions have nothing to point at. The head runs the decision anchor through a normalisation layer and a single linear projection, then a sigmoid, producing P(true) between 0 and 1.

Confidence

Each answer carries a single confidence scalar, normalised so a uniform distribution scores 0 and a one-hot scores 1. It is a compact summary of how peaked the returned distribution is. Because the heads emit normalised probabilities directly, calibration comes from the architecture rather than a post-hoc adjustment.

What the Numbers Say

All numbers are on the first 1,000 items per dataset where dataset size permits; smaller datasets are run in full. Comparison baselines were measured under the same protocol as part of the companion IndicJevBench release.

IndicJevBench

Head-to-head vs. best prior baseline

Weighted across the three comparable datasets: Nirṇaya 0.938 vs. GPT-4o-mini (best prior) 0.676, a 26.2% gain.

JevBench v1 (English, public tiers)

Nirṇaya trades English JevBench performance for larger Indic-side gains. This is by design; see Where It Falls Short below.

On Calibration

A model that says “70% likely this is a payment complaint” should be right about 70% of the time it says that. A wrong-but-uncertain answer is something downstream code can route to a human; a wrong-but-confident one usually isn’t caught until a customer complains.

Nirṇaya’s ECE stays below 0.077 on the three strong IndicJevBench tasks, under the 0.10 threshold we treat as practical-utility. The decision heads emit normalised probabilities directly, so the calibration numbers come from the architecture rather than a temperature layer patched in after training.

hinglish_lid is the exception: ECE 0.553, accuracy 0.155. The cause is discussed below.

Where It Falls Short

Hinglish script detection. Accuracy is 0.155 on hinglish_lid, below the 0.635 majority baseline. The current training mix contains no explicit script-detection examples, so the model has no learned prior for that task shape. A continuation-training run targeting this gap is already under way on a separate model track, with a class balance closer to the natural distribution of code-mixed input. A follow-up release will cover it.

English JevBench regression. The original tier drops from 0.681 mid-training to 0.569 at the final checkpoint, an 11% drop consistent with Indic-heavy fine-tuning pulling the decision heads away from English phrasing. Nirṇaya is India-first by design; we accept this trade.

Score-type calibration on hard questions. The model is overconfident on the hardest JevBench questions. Deployments should fit per-(type, K) temperature scaling on their own calibration split; a recipe will ship with a future release.

Not a generator. Nirṇaya does not produce free-form text. Use a generative model for open-ended tasks.

Language coverage. Trained on 6 Indic languages — Hindi, Bengali, Tamil, Telugu, Kannada, Malayalam — plus English and Hinglish. Marathi, Gujarati and other Indic languages will be added in future releases.

Prompt-injection surface. Because Nirṇaya reads the state as raw text, adversarial content inside the state can still influence probabilities. Do not use it as the sole safety gate for adversarial inputs.

How to Use It

pip install torch --index-url https://download.pytorch.org/whl/cu124   # match your CUDA
pip install git+https://github.com/cmul8/nirnaya.git@v0.1.0

from nirnaya import NirnayaModel

model = NirnayaModel.from_pretrained("cmul8-hf/nirnaya")
result = model.decide(
    state="बिजली बिल का पेमेंट अभी तक नहीं हुआ, urgent hai please",
    questions=[
        {"type": "choice", "options": ["billing", "technical", "sales"]},
        {"type": "score",  "k": 5, "instructions": "How urgent is this?"},
        {"type": "noul",   "instructions": "Should this be escalated?"},
    ],
)
# result[0].probs           -> [0.87, 0.09, 0.04]
# result[1].expected_level  -> 4.2
# result[2].p_true          -> 0.71

All three questions share one backbone forward pass. The inference package (source, install, tests, quickstart) is at github.com/cmul8/nirnaya.

Licence

• Nirṇaya weights: CC BY-NC 4.0.
• Base model: Qwen3-4B’s own licence terms continue to apply to the base weights.

Research, evaluation, personal use, and academic publication are free. Commercial use, including internal use inside a for-profit company on production workloads, requires a separate commercial licence from cmul8.

Where This Fits

Nirṇaya is the first release in an India-first decision-model line, paired with IndicJevBench as the benchmark for structured decision models in Indian languages.

Weights on HuggingFace · Inference package on GitHub · IndicJevBench

References

1. Qwen Team. Qwen3-4B. Backbone used by Nirṇaya, released under the base model's own licence terms.
2. Standhartinger, F. JevBench v1. English public tiers used for the JevBench numbers reported above.
3. Cmul8. IndicJevBench. Companion benchmark that defines the structured-decision tasks Nirṇaya is scored on.

Cite this post

@misc{ghosh2026nirnaya,
  author = {Ghosh, Basab and Sarkale, Sagar and Katte, Abhijeet},
  title  = {Nirṇaya},
  year   = {2026},
  month  = {September},
  url    = {https://www.cmul8.com/research/nirnaya/}
}

Nirṇaya · Weights CC BY-NC 4.0 · Base model Apache-2.0 · September 2026