Introducing Lumma-Fev-27B

In September we released Lumma-Fev, a family of decision models that score the options you supply in a single forward pass instead of generating a label for you to parse. The family ran from 154M to 9B parameters. Today we are adding the biggest one.

Lumma-Fev-27B starts from Qwen3.8-27B and trains every weight, with no LoRA and no frozen layers, on about 100K decision samples. It works in English and three Indic languages: Hindi, Tamil and Kannada. It is the first Fev model we compare head-to-head with TypeSafe Jev on the tasks the family was built for, and we report where it wins and where it does not.

The short version: on a held-out set of 4,454 decisions Lumma-Fev-27B is right 90.7% of the time against 83.9% for Jev, with better-calibrated confidence. On reasoning benchmarks such as BBH and WinoGrande, Jev is still ahead. Both results are below, with the numbers we measured.

The weights are Apache 2.0 at FrontiersMind/Lumma-fev-27B, alongside the rest of the Lumma Decision Models collection.

Same interface, bigger model

Nothing changes in how you call it. You pass a state and a dict of questions, and for each question you get a choice with a probabilities map over the options you defined (or a probability of yes for a noul gate). It is the same /v1/systemone contract as TypeSafe Jev.

Lumma-Fev-27B was trained and evaluated on noul and choice questions only. Treat score answers as untested until you have checked them on your own data.

Compared with Jev

We ran Lumma-Fev-27B and TypeSafe Jev (jev-1.13 through the hosted API) on exactly the same rows, two ways: a held-out set of decisions like the ones we trained on, and eight open benchmarks. All numbers are plain accuracy unless marked, measured in October 2026.

• 90.7% vs 83.9%: accuracy on 4,454 held-out decisions, Lumma-Fev-27B vs Jev
• +6.9 points on the same rows, across nine source tasks
• 0.009 vs 0.045: calibration error (ECE, lower is better) on the same set
• 4 languages: English, plus Hindi, Tamil and Kannada

Benchmarks

4,454 decisions from nine open tasks: reading comprehension, paraphrase, entailment, toxicity, intent and more. Training and test rows come from different source families, so the same source example does not appear on both sides.

Hindi, Tamil and Kannada

There is no public benchmark for decision-making in Indic languages, so we created an internal benchmark for Hindi, Tamil and Kannada.

Confidence you can read

A decision model is only useful for automation if its confidence means something. On the held-out set, Lumma-Fev-27B's calibration error is 0.009 against 0.045 for Jev: when it says 90%, it is right about 90% of the time. The fitted temperature is 0.94, so the raw scores need almost no rescaling.

Each point is a confidence bin with at least 20 test rows; point size grows with the number of rows. The dotted line is perfect calibration.

Calibration is measured on our own test distribution. Fit thresholds on labeled data from your traffic before you gate an automated action on a score.

About 100K training samples

Lumma-Fev-27B was trained on about 100K samples, in a single pass over the data, covering English, Hindi, Tamil and Kannada.

How we trained it

• Base: Qwen3.8-27B, all weights trained, fresh optimizer. A small readout head over the answer options replaces the language-model head.
• Recipe: a short, single-pass fine-tune, inspired by AutoJev.
• Compute: four H200 GPUs for about 3.2 hours (roughly 13 GPU-hours), with the weights sharded across the GPUs.
• Checkpoint choice: every 50 updates we scored a development set against Jev and kept the best checkpoint whose calibration was within 0.01 of Jev's. That turned out to be the last one.

Test it yourself

The weights are about 49 GiB in bfloat16, so plan on a single 80 GB GPU. The calls are the same as for every other Lumma-Fev size.

pip install -U lumma-fev

import lumma_fev

model = lumma_fev.load("FrontiersMind/Lumma-fev-27B")          # or lumma_fev.load("27b")
# model = lumma_fev.load("27b", device_map="auto")             # several GPUs: pip install "lumma-fev[large]"

answers = model.decide(
    state="My integration keeps failing. Please help.",
    questions={
        "team": {
            "type": "choice",
            "instructions": "Which team should handle this request?",
            "criteria": {
                "billing": "Charges and refunds",
                "support": "Technical integration errors",
                "sales": "Questions about buying a product",
            },
        },
        "urgent": {"type": "noul", "instructions": "Does the customer need a reply today?"},
    },
)
print(answers["team"])

Output:

{'type': 'choice', 'choice': 'support', 'confidence': 0.9993,
 'probabilities': {'billing': 0.0002, 'support': 0.9996, 'sales': 0.0002}}

state can be text, a JSON object, or an array. Each question reads the state and its own options only, so one answer never changes another. A noul question returns the probability of yes: answers["urgent"] is {'type': 'noul', 'noul': 0.1058} here.

HTTP API

pip install "lumma-fev[serve]"
lumma-fev-serve --model FrontiersMind/Lumma-fev-27B --host 0.0.0.0 --port 8000

curl -s localhost:8000/v1/systemone -H 'content-type: application/json' -d '{
  "state": "I was charged twice. Please fix this ASAP.",
  "questions": {"billing": {"type": "noul", "instructions": "Is this ticket about billing?"}}
}'

Same /v1/systemone contract as TypeSafe, so existing clients work by changing the base URL.

What we are building next

The gaps above point at the next experiment: a broader training mix that adds public task collections, including reasoning-style and knowledge-style decisions, and a larger run on more GPUs. If you try Lumma-Fev-27B on your own states and option lists, tell us where it breaks. That feedback shapes what we train on next.