Skip to page content
SAVRN
Search Plan a project

Open-weight model · Zero-shot classification

matilda-jev-v1.5

by Maincode Maincode/matilda-jev-v1.5

matilda-jev-v1.5 is an open-weight model for zero-shot classification from Maincode, released under Apache License 2.0. It has 26.1B parameters and a 262,144-token context. At 16-bit it needs about 62.6 GB of GPU memory, which fits on 1x MI300X from $1.85 an hour, at the lowest prices in the SAVRN Index. It draws 36 downloads a month.

A BF16 JEV decision model with a 255-option readout. This is the highest-scoring checkpoint in the completed MATILDA JEV experiments as of 9 October 2026: Decision Index 63.47 (0.3 public suite). The model accepts a state and one or more decision questions.

Parameters26.1B
Context262,144
Weights52.2 GB
Licenseapache-2.0
AccessOpen weights
Monthly Downloads36

Runs On

What it takes to serve matilda-jev-v1.5 (26.1B parameters): the memory its weights need at each precision, and the cheapest way to rent enough data-center GPUs to hold them.

PrecisionWeightsMemory neededCheapest setupPer hourAlso fits
16-bit 52.2 GB 62.6 GB 1x MI300X (192 GB)
Vultr
$1.85 1x H100 $1.99 · 1x MI325X $2.00
8-bit 26.1 GB 31.3 GB 1x MI300X (192 GB)
Vultr
$1.85 1x H100 $1.99 · 1x MI325X $2.00
4-bit 13.0 GB 15.7 GB 1x MI300X (192 GB)
Vultr
$1.85 1x H100 $1.99 · 1x MI325X $2.00

Memory is the weights at that precision plus 20% for the runtime and a short context; a long context needs more. Prices are the lowest on-demand hourly rates in the SAVRN Index, read Oct 18, 2026.

matilda-jev-v1.5 on every accelerator the SAVRN Index prices, at every precision

Model Card

By Maincode, published under apache-2.0, revision 9a732d3d635e.

A BF16 JEV decision model with a 255-option readout. This is the highest-scoring checkpoint in the completed MATILDA JEV experiments as of 9 October 2026: Decision Index 63.47 (0.3 public suite). The model accepts a state and one or more decision questions. It supports choice, noul (probability of true), and ordinal score. Inference is one forward pass per question; the model has no text-generation head and does not generate a chain of thought. The LoRA updates are already merged into the weights. No adapter merge is required. Use Python 3.12 or newer and install PyTorch for your accelerator. The validated cluster environment uses PyTorch 2.14.0, Transformers 5.17.0, and an AMD Instinct…

Read Maincode's full model card

MATILDA JEV v1.5 by Maincode

All scores on this card are from the Decision Index 0.3 public suite (the public dataset of the current leaderboard edition).

A BF16 JEV decision model with a 255-option readout. This is the highest-scoring checkpoint in the completed MATILDA JEV experiments as of 9 October 2026: Decision Index 63.47 (0.3 public suite).

The model accepts a state and one or more decision questions. It supports choice, noul (probability of true), and ordinal score. Inference is one forward pass per question; the model has no text-generation head and does not generate a chain of thought. The LoRA updates are already merged into the weights. No adapter merge is required.

Loading

Use Python 3.12 or newer and install PyTorch for your accelerator. The validated cluster environment uses PyTorch 2.14.0, Transformers 5.17.0, and an AMD Instinct MI355X. Other dependencies are listed in requirements-runtime.txt.

import sys
from pathlib import Path
from huggingface_hub import snapshot_download

checkpoint = Path(snapshot_download('Maincode/matilda-jev-v1.5'))
sys.path.insert(0, str(checkpoint / 'runtime'))
from maincode_jev_serve.model import DecisionModel, answer

model = DecisionModel(checkpoint=checkpoint, device='cuda:0')
row = {
    'state': 'The parcel arrived on schedule.',
    'question': {
        'type': 'choice',
        'instructions': 'Classify delivery.',
        'criteria': {'on_time': 'On time', 'late': 'Late'},
    },
}
print(answer(row['question'], model.predict([row])[0]))

The loader uses the custom code bundled in this repository. AutoModel alone loads the backbone; use DecisionModel to include the separate decision head. The package retains the existing MATILDA configuration aliases and the underlying Transformers implementation. Model weights, tokenizer vocabulary, input template, answer codes, readout, and temperature match the evaluated checkpoint.

predict.py accepts JSON lines containing either state + question or state + questions:

{"state":"Two plus two equals four.","questions":{"truth":{"type":"noul","instructions":"Is this statement true?"}}}
python /path/to/downloaded/model/predict.py --device cuda:0 < requests.jsonl

Evaluation

Decision Index 0.3 public suite: 140,178 of 140,178 scored requests answered across 37 benchmarks (kit 62d2f51). Saved predictions were independently rescored with identical results. The full run, including every prediction, is in Maincode/matilda-jev-decision-index under runs/matilda-jev-v1.5/. scores.json in this repository is the earlier 0.2.1 run (62.76), kept for reference.

Metric Jev MATILDA JEV v1 MATILDA JEV v1.5
Decision Index (public) 57.96 60.16 63.47
Raw 68.55 70.04 72.62
Breadth 57.27 59.21 62.45
Knowledge & Reasoning 53.87 46.84 49.83
Language Understanding 59.23 64.80 69.91
Retrieval & Classification 55.42 61.07 65.96
Tools & Automation 75.09 79.07 80.84
Arts & Human Taste 39.08 46.22 45.41

Jev is the public-suite part of its Decision Index 0.3 board entry (per-benchmark public results, as published in the kit's tests/fixtures/board-0.3.json), not its Full score. MATILDA JEV v1 is Maincode/matilda-jev-v1 (runs/matilda-jev-v1.3/ in the same dataset).

Area scores are chance-corrected skill multiplied by 100. These results are diagnostic: earlier training in this model's lineage used benchmark-related material, and this release was chosen after comparing experimental scores. The numbers are not an independent held-out generalization estimate. The full suite evaluated text decisions; vision inference was not validated for this release.

Configuration

Architecture
MatildaJevModel
Context length (tokens)
262,144
Layers
64
Hidden size
5,120
Feed-forward size
17,408
Attention heads
24
Key/value heads
4
Head dimension
256
Vocabulary size
248,320
Model type
matilda_jev

Identity and Version

Repository
Maincode/matilda-jev-v1.5
Publisher
Maincode
Task
Zero-shot classification
Modality
Text
Library
transformers
Parameters
26.1B parameters
Languages
jev
Revision
9a732d3d635e519ab06e21f9c60db3b2acd1eed1
First published
2026-10-09
Last updated
2026-10-13

Files and Weights

37 files, 52.2 GB in total. The weights are 12 files totalling 52.2 GB in safetensors.

Weights12 files · 52.2 GB
Configuration17 files · 162.0 KB
Tokenizer2 files · 20.0 MB
Documentation2 files · 15.8 KB
Other3 files · 30.7 KB
Repository1 file · 1.6 KB
Every file
FileTypeSizeSHA-256
model-00001-of-00011.safetensorsWeights4.8 GB a953bdd1e1f3
model-00002-of-00011.safetensorsWeights5.0 GB caec1eebfd61
model-00003-of-00011.safetensorsWeights4.9 GB 1f4786c2549b
model-00004-of-00011.safetensorsWeights5.0 GB 51cd1297453e
model-00005-of-00011.safetensorsWeights4.9 GB 60706eecdf42
model-00006-of-00011.safetensorsWeights4.9 GB dc8e99392f55
model-00007-of-00011.safetensorsWeights5.0 GB 8a3304915402
model-00008-of-00011.safetensorsWeights5.0 GB 68c4b39badbd
model-00009-of-00011.safetensorsWeights4.9 GB 87f5e70b3622
model-00010-of-00011.safetensorsWeights5.0 GB 4820c48d65ea
model-00011-of-00011.safetensorsWeights2.8 GB b61b3f98667d
readout.safetensorsWeights2.6 MB ce692e0ef00a
config.jsonConfiguration3.9 KB —
configuration_matilda_jev.pyConfiguration603 B —
decision_config.jsonConfiguration5.3 KB —
model.safetensors.index.jsonConfiguration104.0 KB —
modeling_matilda_jev.pyConfiguration1.3 KB —
predict.pyConfiguration1.4 KB —
processing_matilda_jev.pyConfiguration1.5 KB —
processor_config.jsonConfiguration1.3 KB —
runtime/maincode_jev_serve/__init__.pyConfiguration —
runtime/maincode_jev_serve/ask.pyConfiguration4.8 KB —
runtime/maincode_jev_serve/config.pyConfiguration2.1 KB —
runtime/maincode_jev_serve/decide.pyConfiguration3.7 KB —
runtime/maincode_jev_serve/engine.pyConfiguration3.3 KB —
runtime/maincode_jev_serve/model.pyConfiguration14.4 KB —
runtime/maincode_jev_serve/server.pyConfiguration12.2 KB —
runtime/maincode_jev_serve/types.pyConfiguration1.9 KB —
tokenization_matilda_jev.pyConfiguration280 B —
LICENSEDocumentation11.5 KB —
README.mdDocumentation4.2 KB —
chat_template.jinjaOther9.0 KB —
requirements-runtime.txtOther220 B —
runtime/maincode_jev_serve/playground.htmlOther21.5 KB —
.gitattributesRepository1.6 KB —
tokenizer.jsonTokenizer20.0 MB 06b9509352d2
tokenizer_config.jsonTokenizer1.5 KB —

License and Download

License
apache-2.0
Access
Open weights, no gate
Download size
52.2 GB
Download from Maincode

Released by Maincode through its official repository on Hugging Face. Read the license.

Built From

Memory Requirements

PrecisionWeights in memory
As published52.2 GB
16-bit52.2 GB
8-bit26.1 GB
4-bit13.0 GB

Weights only, from the published parameter count; the key-value cache and runtime add to this.

Questions About matilda-jev-v1.5

How much GPU memory does matilda-jev-v1.5 need?

About 62.6 GB at 16-bit and 15.7 GB at 4-bit: the weights (26.1B parameters) plus a working margin. A long context needs more.

What is the cheapest GPU to run matilda-jev-v1.5 on?

At 16-bit, 1x MI300X from $1.85 an hour; at 4-bit, 1x MI300X from $1.85 an hour, at the lowest on-demand prices the SAVRN Index lists.

Can I use matilda-jev-v1.5 commercially?

Yes. matilda-jev-v1.5 is released under Apache License 2.0. The Apache License 2.0 is a permissive open-source license. It permits commercial use, modification and redistribution. It requires keeping the license and copyright notices and any NOTICE file, stating significant changes, and it includes an express patent grant from contributors.

What is matilda-jev-v1.5's context length?

262,144 tokens, from the maximum position embeddings in its published configuration.

Similar Models

Model · Zero-shot classification

matilda-jev-v1

Maincode

Matilda-Jev is Maincode's one-pass decision model. It scores the options supplied in a choice, noul (yes/no), or ordered score question. It accepts text or JSON state and optional images. This is a decision checkpoint with a 255-option readout, not a text-generation checkpoint. This configuration edition uses MatildaJevModel, MatildaJevConfig, and MATILDA tokenizer/processor classes. Use the bundled runtime below, or load the custom AutoClasses with trustremotecode=True. The package includes the backbone weights, decision readout, tokenizer, preprocessing configuration and calibrated temperature. On AMD MI355X with Python 3.12, Transformers 5.17.0 and PyTorch 2.14.0: - 25/25 smoke-test…

Open weights apache-2.0 26.1B parameters 262,144 tokens transformers

Model · Zero-shot classification

d3-oQ8e

Jun Kim

This model was quantized using oQ (oMLX v0.7.1) mixed-precision quantization with Improved oQe Quantization (jundot/omlx#4385). A mixed-precision MLX checkpoint of vllm-sr/d3, the 27B multimodal decision model of Decision 3.0 from vLLM Semantic Router, built on Qwen/Qwen3.8-27B. It reads text or JSON with optional images and videos and returns a probability for every option of choice, yes/no and score questions without generating text. It includes the language backbone, the vision encoder and the code readout. The code readout (readout.safetensors, FP32) and decisionconfig.json are copied unchanged from the source. oMLX serves this checkpoint through POST /v1/systemone; Decision 3.0 support…

Open weights apache-2.0 26.1B parameters 262,144 tokens mlx

Model · Zero-shot classification

d3-oQ4e

Jun Kim

This model was quantized using oQ (oMLX v0.7.1) mixed-precision quantization with Improved oQe Quantization (jundot/omlx#4385). A mixed-precision MLX checkpoint of vllm-sr/d3, the 27B multimodal decision model of Decision 3.0 from vLLM Semantic Router, built on Qwen/Qwen3.8-27B. It reads text or JSON with optional images and videos and returns a probability for every option of choice, yes/no and score questions without generating text. It includes the language backbone, the vision encoder and the code readout. The code readout (readout.safetensors, FP32) and decisionconfig.json are copied unchanged from the source. oMLX serves this checkpoint through POST /v1/systemone; Decision 3.0 support…

Open weights apache-2.0 26.1B parameters 262,144 tokens mlx

Model · Zero-shot classification

d3-W4A16-G128-AWQ

Park Soobin

d3-W4A16-G128-AWQ is an unofficial INT4 weight-only (W4A16) AWQ quantization of d3, the 27B multimodal foundation decision model of Decision 3.0. It takes the same inputs and questions as d3 and returns a probability for every answer, without generating text, with 16.5 GB of weights instead of 52 GB. - Keeps 97.76% of d3's answers on the 14,031 test requests of tasksource-jev-typed-decisions, with accuracy 83.09% against BF16's 83.25%. - 16.9 GB of GPU memory after loading instead of 52.3 GB, and 17.5 GB at the peak of the 20 longest of 1,000 text requests (up to 5,928 characters of state) on an MI300X. - Reads images and videos as d3 does: the vision tower is unchanged, and d3's example…

Open weights apache-2.0 26.1B parameters 262,144 tokens transformers

Model · Zero-shot classification

bobcat-flash-1.2

Sanghwa Na

Bobcat Flash 1.2 · Bobcat Flash 1.2 FP8 · Try it in the Space · Code on GitHub Bobcat Flash is the fast tier of Bobcat, a typed-decision model. You send a state (text or JSON) and questions whose possible answers you define in the request; Flash returns a probability for every answer you named, and nothing else. It never generates text: it reads the logits of the offered candidates at the first answer position of one forward pass, and the host builds a closed JSON reply from your own names. An answer can be wrong, but it cannot be malformed. This repository, sanghwa-na/bobcat-flash-1.2, holds Bobcat Flash 1.2 as ready-to-serve BF16 weights on google/gemma-4-26B-A4B-it (Apache-2.0) at…

Open weights apache-2.0 25.8B parameters 262,144 tokens transformers

Model · Zero-shot classification

bobcat-flash-1.2-fp8

Sanghwa Na

A pre-quantized FP8 checkpoint of Bobcat Flash 1.2, the fast tier of the typed-decision model Bobcat: you send a state and questions whose answers you name, and it returns a probability for every answer you named; it never generates text. Evaluation, training data, limitations and the full license notes are on the main card, This repository, sanghwa-na/bobcat-flash-1.2-fp8, is the BF16 weights of sanghwa-na/bobcat-flash-1.2 quantized to FP8 (27.2 GB, FP8DYNAMIC, every expert included): float8e4m3fn weights with one scale per output channel, activations quantized per token at run time, in the compressed-tensors format that vLLM loads as it is. It is the checkpoint the Bobcat Flash Space…

Open weights apache-2.0 25.8B parameters 262,144 tokens transformers