Introducing Lumma-Fev-v2

Overview

A Decision Model, Not a Generator

Each Lumma-Fev model takes a state, which can be text, a JSON object or an array, plus a set of typed questions. It scores every option of every question at once and hands the probabilities back. Because the answer is a distribution and not a sentence, you can set a threshold, route on the top option, or send low-confidence cases to a person.

The Family

One Family, Four Sizes

Every Lumma-Fev decision model is a fine-tune of a pretrained base model. The small ones start from our own Nandi-Mini and Lumma foundation models, the larger ones from Qwen3.8. The interface does not change between them, so you can prototype on a small model and move up, or down, without touching your code.

Our first-generation decision models (0.1B, 0.6B, 4B and 9B) are in the Lumma Decision Models collection.

What Changed

What Changed in v2

Lumma-Fev-27B-v2 is the flagship of the family and the successor to Lumma-Fev-27B. Three things are different.

Bidirectional Attention

In Lumma-Fev-27B-v2, the full-attention layers read the whole prompt in both directions, like an encoder. The Gated DeltaNet (linear-attention) layers stay causal. For a decision model that is a natural fit: the state and the questions are all in the prompt before any answer is scored, so there is no reason for an early token to be blind to a later one.

3× the Training Data

Lumma-Fev-27B-v2 trains on about 300K samples, up from about 100K for v1.

Trained With decisionformer

We trained the Lumma-Fev-v2 models with decisionformer, our open-source (Apache 2.0) library for fine-tuning, loading and serving calibrated decision models on any Hugging Face model. It supports full, LoRA, QLoRA and head-only fine-tuning through YAML recipes, with a CLI and multi-GPU support, and it includes tools to evaluate and compare checkpoints and push them to the Hub. If you want to train your own decision model, start there.

Interface

The Same Interface as v1

Every Lumma-Fev-v2 model uses the interface of v1, so nothing changes for existing users. Each model takes a state and a set of typed questions. Each answer comes back with its type, the choice, a confidence, and the full probabilities over every option.

The models work in English, Hindi, Tamil and Kannada, plus Hinglish.

Results

Compared With Jev

We evaluated on the test splits of eight public benchmarks, using the same rows for every model.

Hindi, Tamil and Kannada

There is no public benchmark for decision-making in Indic languages, so we use an internal one. All three systems answered the same 400 rows: 100 each in English, Hindi, Tamil and Kannada, translated by Claude from our held-out test tasks.

Averaged over Hindi, Tamil and Kannada, Lumma-Fev-27B-v2 scores 87.7% and Lumma-Fev-4B-v2 scores 85.3%, against 79.7% for Jev.

Calibration

Confidence You Can Read

A decision model is only useful for automation if its probabilities mean something. Both Lumma-Fev-v2 models beat Jev on log loss, ECE and Brier, and Lumma-Fev-27B-v2 is the best calibrated of the three on every metric.

The reliability diagram shows it directly. Each point is a confidence bin, and the closer a point sits to the dotted diagonal, the more the model's stated confidence matches how often it is right. The two Lumma-Fev-v2 models follow the diagonal closely, while Jev sits below it: when Jev says 90%, it is right about 80% of the time.

On the pooled rows, the calibration error (ECE) is 0.004 for Lumma-Fev-4B-v2 and 0.010 for Lumma-Fev-27B-v2, against 0.091 for Jev. Averaged benchmark by benchmark instead, the picture below is the one we reported: the 27B is the best calibrated of the three on every metric.

On the Indic Benchmark

On the internal Indic benchmark, averaged over Hindi, Tamil and Kannada, Lumma-Fev-27B-v2 has the best Brier score and log loss of the three, and its ECE of 0.084 is close to Jev's 0.080. Lumma-Fev-4B-v2 is better than Jev on Brier and log loss, but its ECE is higher at 0.096.

Run It

Test It Yourself

Install

pip install "lumma-fev>=0.3"

Version 0.3 or later is required to load Lumma-Fev-27B-v2, because it uses bidirectional attention.

Python

import lumma_fev

model = lumma_fev.load("FrontiersMind/Lumma-fev-27B-v2")       # or lumma_fev.load("27b-v2")
# model = lumma_fev.load("FrontiersMind/Lumma-fev-4B-v2")      # smaller model, same interface
# model = lumma_fev.load("27b-v2", 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"])
# {"type": "choice", "choice": "support", "confidence": 0.99..., "probabilities": {"billing": ..., "support": ..., "sales": ...}}

Images

Install the extra and pass images=[...] as paths, PIL images or data: URLs.

pip install "lumma-fev[images]"

HTTP API

To serve a model behind the TypeSafe-compatible POST /v1/systemone API:

pip install "lumma-fev[serve]"
lumma-fev-serve --model 27b-v2 --host 0.0.0.0 --port 8000       # add --device-map auto for several GPUs

Limits

Requirements and Limits

• GPU memory (27B-v2): about 55 GB free, which is a single 80 GB card, or several smaller GPUs with device_map="auto".
• Precision: BF16, Safetensors.
• Context: a question plus the state must fit in 8,192 tokens.
• score questions: accepted but untested.
• Loading the 27B-v2 weights yourself: decision_config.json has "attention_mode": "noncausal_full_attention". Set config.is_causal = False on the text config and is_causal = False on every text attention module after loading. Setting only the config makes single unpadded requests run causally.

Lumma-Fev-27B-v2 at a Glance

What Is Next

What We Are Building Next

Lumma-Fev-0.1B-v2 and Lumma-Fev-0.6B-v2 are coming soon, built on Nandi-Mini-150M and Lumma-0.6B-Base. Jev still leads on BBH and JudgeBench, so reasoning remains the main gap for the family.

Try the Lumma-Fev-v2 models on your own decisions, and tell us where they fail. Those failures shape the next version. To fine-tune your own decision model, use decisionformer.