Strands Decider is a decision model for agentic AI. A large language model (LLM) generates arbitrary text; a decision model picks between sets of options and rates things on a scale, and every answer carries a calibrated confidence.
You send a state (the text a decision is about) and one or more questions, each of one type: choice (one of 2 to 255 options), noul (yes/no) or score (a level on an ordered scale). In one pass, with no generated text, the model returns a probability for each option. The questions and options are in the request, so the same model answers a new decision with no more training.
This repository holds the E2B model, the smallest of the five in Strands Decider v2. Each is a Gemma 4 instruction model from Google, fine-tuned for decisions. This one follows strands-decider-E2B-gemma4-v1-2610 on the same base model. Code: https://github.com/strands-labs/strands-decider, under the same Apache-2.0 license as this model.
| Base model | google/gemma-4-E2B-it, 2.3B effective parameters (5.1B with embeddings) |
| Inputs | A state (text or JSON, with optional images) and any number of typed questions about it |
| Decision types | Choice (2 to 255 options) · Yes / No · Score (2 to 10 levels) |
| Context | 32,768 tokens (validated; the default limit), up to 131,072 |
| Size | 10.3 GB of weights in bf16; one GPU with 24 GB of memory |
| Results | 57.1 on the Decision Index 0.3, 27.8 points over Strands Decider v1 E2B. An average gap of 3.2 points between confidence and accuracy. 62 ms for one question on one NVIDIA H100 GPU, and 92 ms for 30 questions about one state |
| Version | v2, the second release of Strands Decider. Names follow strands-decider-{size}-{base}-v{N}-{YYMM} (naming rule) |
| Developed by | The Strands Decider team, in Strands Labs |
| Documentation | https://strandsagents.com/docs/labs/strands-decider/overview/ |
| License | Apache-2.0 |
The five v2 models take the same request and give the same kind of answer, so a change of model is a change of one name. All Strands Decider models are at https://huggingface.co/StrandsAgents.
| Model | Base model | Parameters | Weights in bf16 | Pick it for |
|---|---|---|---|---|
| E2B (this model) | gemma-4-E2B-it | 2.3B effective (5.1B with embeddings) | 10.3 GB | The smallest model: one 24 GB GPU, or no GPU |
| E4B | gemma-4-E4B-it | 4.5B effective (8B with embeddings) | 16 GB | One 40 GB GPU |
| 12B | gemma-4-12B-it | 11.95B | 24 GB | One 48 GB GPU |
| 26B-A4B | gemma-4-26B-A4B-it | 25.2B, 3.8B active (128 experts) | 52 GB | One 80 GB GPU, many questions about one state |
| 31B | gemma-4-31B-it | 30.7B | 63 GB | The most accurate model, on one 80 GB GPU |
Contents: How to get started · Evaluation · Uses · How the model works · Training · Limitations and risks · Files and checkpoint format · License and attribution · Citation · Report a problem
You need one NVIDIA GPU with 24 GB of memory, 10.3 GB of disk for the weights and Python 3.11 or later. This size also runs on a CPU, more slowly: add --device cpu to a command, or write device="cpu" in Python.
pip install strands-decider
strands-decider ask StrandsAgents/strands-decider-E2B-gemma4-v2-2611 \
--state 'Help! My payouts have been failing for 3 days!' \
--noul "Does this convey urgency?" \
--choice "Which team should handle this?=billing,sales,retail" \
--score "How frustrated is the writer?=calm,frustrated,very angry"
At first use, the command downloads the model from Hugging Face. It names the questions noul_0, choice_0 and score_0. This is the output of this model on a CPU. On a GPU the last digits can differ:
noul_0 noul = 0.929
choice_0 -> billing (confidence 0.969)
billing 0.979
sales 0.010
retail 0.010
score_0 score = 1.26 (confidence 0.533)
0: calm 0.013
1: frustrated 0.714
2: very angry 0.273
How to read the output:
--noul asks a yes/no question: noul is the name of this question type. The answer is the probability of "yes", so a value near 0 is a confident "no" and a value near 1 is a confident "yes". Read it as "yes" above a threshold that you pick for the task: 0.5 is the natural default.--choice gives the best option and a probability for each option.--score gives a value on a scale, here from 0 (calm) to 2 (very angry). The value is the expected level, so it can fall between two levels.Add --image photo.jpg, once for each image, to send images with the state.
strands-decider serve StrandsAgents/strands-decider-E2B-gemma4-v2-2611 --port 8000
The server binds to 127.0.0.1 and has no authentication: use it for local experiments. It answers POST /v1/systemone with the same engine as strands-decider ask. GET /health and GET /ping report that the server is up.
curl -s localhost:8000/v1/systemone -H 'content-type: application/json' -d '{
"state": "Help! My payouts have been failing for 3 days!",
"questions": {
"is_urgent": {"type": "noul", "instructions": "Does this convey urgency?"},
"team": {"type": "choice", "instructions": "Which team should handle this?",
"criteria": {"billing": null, "sales": null, "retail": null}}
}
}'
The answer has the same question names. This sample is from an NVIDIA GPU, and it leaves out usage (the token counts) and latency_ms, which the answer also has:
{
"model": "strands-decider-E2B-gemma4-v2-2611",
"answers": {
"is_urgent": {"type": "noul", "noul": 0.929},
"team": {"type": "choice", "choice": "billing",
"probabilities": {"billing": 0.98, "sales": 0.0098, "retail": 0.0102},
"confidence": 0.97}
}
}
from strands_decider.core import Request
from strands_decider.decision import load_decision_engine
engine = load_decision_engine("StrandsAgents/strands-decider-E2B-gemma4-v2-2611", device="cuda")
response = engine.evaluate(Request.model_validate({
"state": "My integration keeps failing with a 401 since we rotated our API key. 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": "Is the customer blocked right now?"},
"frustration": {"type": "score", "instructions": "How frustrated is the customer?",
"criteria": ["calm", "mildly annoyed", "frustrated", "angry"]},
},
}))
answers = response.model_dump(exclude_none=True)["answers"]
print(answers["team"]["choice"], answers["urgent"]["noul"])
The command line, the server and Python take the same request:
{
"state": str | dict | list, # the context to decide on; non-strings are serialized as JSON
"images": [str], # optional: each image a base64 PNG, JPEG, WebP or GIF of at most
# 16 MB, with or without a data:image/...;base64, prefix
"questions": { # 1 or more questions, answered from the same state
"<id>": {
"type": "choice" | "noul" | "score",
"instructions": str, # the question
"criteria": ..., # see below
},
},
}
| Type | criteria |
Answer |
|---|---|---|
choice |
{option_name: description or None}, 2 to 255 options |
choice, probabilities (per option), confidence |
noul |
optional {"true": description, "false": description} |
noul = P(true), the probability of yes |
score |
list of ordered levels, lowest first, 2 to 10 levels | score (expected level index), probabilities, legend (the label of each level), confidence |
The options are shown to the model in the order you give them, under the answer codes A, B, ... In criteria, a description tells the model what an option means.
A prompt (the state plus one question) of up to 32,768 tokens is served by default, and of up to 131,072 with load_decision_engine(..., max_length=131072) or strands-decider serve --max-length 131072. Inputs are never truncated: the server refuses a prompt that is too long with HTTP status 422, and the reason is in the detail field.
An answer does not change when you add, remove or reorder the other questions of a request, and each extra question costs only its own tokens: Latency has the time for 1 question and for 30. Put all the questions about one state in the same request.
Scores go from 0 to 100, and higher is better. The last row is the v1 model of the same size. Each v2 row is at the temperature that its model ships with (for this model, T = 1.5456), and the v1 row is at a temperature of 1. Of these benchmarks, only OpenDecisions depends on the temperature, which Calibration explains: this model scores 76.2 there at a temperature of 1, as on the Jev leaderboard.
| Model | Decision Index 0.3, public | JevBench | OpenDecisions | DecisionPivot | BEV |
|---|---|---|---|---|---|
| v2 E2B (this model) | 57.1 | 87.4 | 77.7 | 23.3 | 74.0 |
| v2 E4B | 63.2 | 88.3 | 83.9 | 45.2 | 78.9 |
| v2 12B | 64.1 | 92.2 | 85.7 | 58.9 | 79.0 |
| v2 26B-A4B | 69.0 | 92.6 | 88.6 | 69.2 | 81.4 |
| v2 31B | 71.5 | 93.1 | 92.2 | 84.3 | 84.5 |
| v1 E2B | 29.3 | 77.5 | 56.8 | 7.3 | 63.9 |
| Benchmark | What it measures |
|---|---|
| Decision Index 0.3, public | 41 tasks in five areas |
| JevBench | The share of the 231 public items answered correctly |
| OpenDecisions | Everyday decisions, scored on answer quality and calibration |
| DecisionPivot | Pair accuracy on items that differ in one decisive detail |
| BEV | Choice, yes/no and ordered-score decisions across 18 domains |
The Decision Index and JevBench links open public leaderboards, which show the scores of other models on the same benchmarks.
A model is calibrated when its probabilities follow its accuracy: of the answers that get a probability of 0.9, about 90% are right. For this model, the average gap between confidence and accuracy is 3.2 points.
One temperature, a number that scales the scores of the options before they become probabilities, makes the probabilities follow the accuracy. decision_config.json stores the temperature fitted on held-out data (1.5456 for this checkpoint), and every runtime (a program that runs the model) applies it once. The temperature does not change which option has the highest probability. It changes the probability values. You do not set it in a request.
On one NVIDIA H100 GPU in bf16, the median request over JevBench's 231 items takes 62 ms with one question and 92 ms with 30 questions on the same state.
Use the model where your application makes the same kind of decision again and again, and where you can list the possible answers before the request. Typical decisions:
The model does not write text, explain an answer or add an option of its own. When a task needs generated text, a conversation, code or a summary, use a generative model, and use Strands Decider to decide when to call it.
A decision, not a generation. A language model generates text token by token. Strands Decider does not. The request fixes the possible answers, so one forward pass gives one score for each option, and a softmax over the scores of a question's own options is the answer. There is no decoding loop.
Answer codes and a token readout. The prompt lists the options of a question under short answer codes (A, B, C, ...). Gemma 4 ends in an LM head, the layer that scores every token of the vocabulary to generate text. This model replaces it with a token readout of 255 rows, one for each answer code. Each row starts from the LM head's row for its code and is trained with the model, and the rest of the LM head is dropped. Each option's probability is read from its code at the last token of the prompt. The readout has rows for codes, not for options, so a new set of options needs no change to the model. How well it answers depends on the decision: measure on your own data before you rely on it.
One state, read once and in both directions. The state is encoded once, and every question reads it. A state token sees all of the state, the text before it and the text after it, and never a question. A question token sees the state and its own question, so no question sees another. Most layers of Gemma 4 are sliding-window layers, which see only a window of nearby tokens: in this model, every layer sees the whole prompt.
Technical facts of this checkpoint| Decoder | Gemma 4 E2B: 35 layers, hidden size 1,536 |
| Readout | 255 answer codes × 1,536, in bf16 |
| Attention | prefix_bidir on every layer, with no window |
| Prompt format | strands-chat |
| Temperature | 1.5456 |
| Strands Decider v1 on Gemma 4 | Strands Decider v2 | |
|---|---|---|
| Sizes | E2B, E4B, 12B, 26B-A4B | E2B, E4B, 12B, 26B-A4B, 31B |
| Readout | A pointer head added to the decoder. It scores each option from the state of the decoder at the answer position and at the last token of the option | A token readout instead of the LM head |
| Attention | Causal: a token sees only the text before it | The state in both directions |
| Checkpoint | A LoRA adapter (a small set of extra weights) and a head, next to the base model | One full model, with the adapter merged in |
| Inputs | Text | Text and images |
| Calibration | One temperature for each question type | One temperature for all question types |
| Training data | 135,602 rows | 17.48 million rows |
| LoRA rank | 16 in each run | 64 |
Strands Decider v2 trains on a data mix of 17.5 million rows of text (8.9 billion tokens). Each row is one decision: a state, a question and 2 to 255 options. Language models wrote 72% of the rows from task specifications. 6% come from generator programs in known task formats, and 22% come from more than 200 public datasets, converted to the same format. The rows cover 13 topics, such as knowledge questions, reasoning, judging responses against rubrics, tool use and safety. About 96% of the rows are in English, and none is longer than 16,384 tokens. The data card gives the counts, the kinds of source, the topics, the shape of the rows and sample rows.
Training starts from google/gemma-4-E2B-it at the revision that License and attribution names. It adds a LoRA adapter of rank 64 and trains it with the token readout. The base model's own weights stay as they are.
A run makes one pass over the data mix, with about 2,700 rows for each update of the weights. It uses no teacher model: the target of each row is all that a run trains toward, with a cross-entropy loss on the answer. Attention in training is the same as in use.
The released model is the average of three runs of the same config with different random seeds: the export merges the adapter of each run into the base model and averages the results with equal weights. Then the temperature is fitted on held-out questions and written into decision_config.json.
The config of this size is configs/v2/strands-decider-E2B-gemma4-v2-2611.yaml, and the v2 recipes have the steps: convert the rows, train one config and export.
out_of_scope or "I don't know". The training data has rows with such options.| File | Content |
|---|---|
model.safetensors |
Gemma 4 E2B's own checkpoint, every tensor under the base's names, with the fine-tuned decoder merged in |
readout.safetensors |
The decision readout: a bf16 tensor of 255 × 1,536 (answer codes × hidden size) |
decision_config.json |
The prompt format (strands-chat), the 255 answer codes and their token ids, the temperature, the attention mode (prefix_bidir), the validated prompt length and the revision of the base model |
config.json, processor_config.json, tokenizer.json, tokenizer_config.json |
The configuration of the model and of its input processor, and the tokenizer |
golden_vectors.jsonl |
The reference answers that a runtime is checked against |
LICENSE, NOTICE |
The Apache-2.0 license, and the notice that names the base model and what changed |
README.md, assets/strands-decider-v2-E2B.png |
This card and its picture |
.gitattributes |
The Git settings of the repository |
This is the decision-checkpoint layout of the decision interface, which the code repository defines. The attention mode prefix_bidir is the attention that How the model works describes. The repository has no chat template and no code. The token readout in the code repository describes the export that writes the weights, the readout, decision_config.json and the configuration files.
The weights of this repository and the code of Strands Decider have the Apache-2.0 license (LICENSE).
This model is derived from google/gemma-4-E2B-it, revision 3e22461f65e89153144f8adb70e3b8c2cc9845a7, under the Apache License 2.0. NOTICE states what changed:
Modifications: the text decoder was fine-tuned, and a decision readout of 255 rows, one per answer code, takes the place of the generation output layer; it started from the tied output-embedding rows of those codes. Every layer reads the prompt with the decision interface's prefix-bidirectional attention. Every other part of the base model, its image and audio input layers where it has them, is the base model's, unchanged.
Gemma is a trademark of Google LLC. No affiliation with or endorsement by Google is implied.
To cite the Strands Decider v2 models:
@misc{strandsdecider2026v2,
title = {Strands Decider v2: Open, Calibrated Decision Models from E2B to 31B},
author = {{The Strands Decider team}},
year = {2026},
howpublished = {\url{https://github.com/strands-labs/strands-decider}},
note = {Model weights: https://huggingface.co/StrandsAgents}
}
model.safetensors 10 GBreadout.safetensors 783.5 kBgoogle/gemma-4-E2B-it