EmbeddingGemma 2 Typed Decisions

EmbeddingGemma 2 Typed Decisions

A 272M model, fine-tuned from EmbeddingGemma 2, that reads the state of a workflow and a schema of questions and returns a typed answer with a calibrated confidence for each question.

Made by mrm8488 on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: This is a typed decision model, fine-tuned from Google's EmbeddingGemma 2 and holding 272M parameters. You give it the state of a workflow, such as security alerts, invoices, support tickets or agent traces, plus a schema of questions. It returns a typed answer to each question with a calibrated confidence. There are three question types: a choice among options, a score on a level scale, and a probabilistic yes or no.

Who it suits: It suits developers who build agent monitoring, ticket triage or review queues and want a small model that picks among options they define.

Industry | Who uses it | How they use it | Example
Agent operations | Teams that monitor AI agents | Decide what to do with an agent run | Choose between continue, observe, human review and stop for a trace
Support | Help-desk teams | Triage tickets with a typed schema | Ask whether a ticket needs a person to review it
Finance and security | Back-office and security teams | Rate the risk of invoices or alerts | Score an alert on a level scale from 0 to 3

If you need free-text answers, you can skip it, since it picks among options you give it. Keep a person in the loop for decisions with real consequences.

Where to use it:

• Python projects with transformers, using the repository's custom code
• Agent monitoring, ticket triage and review queues
• Windows, macOS or Linux with Python, to download the files

Use case | Who | What they get back
Agent trace review | Observability teams | A chosen option such as continue or stop, with a confidence
Risk scoring | Risk teams | A level from the scale you describe, with probabilities
Review flags | Ticket queues | A yes or no with a probability

How to set it up: What you need first:

• Python with transformers
• Willingness to let the repository's custom code run, through trust_remote_code
• Room for about 1.1 GB of F32 weights, or about 136 MB at 4-bit, which is an estimate

1. Install the Hugging Face tools and download the files.
2. Load the model with AutoModel and trust_remote_code.
3. Describe your state and questions as plain data, then call decide.

pip install -U huggingface_hub
hf download mrm8488/embeddinggemma-2-ft-typed-decision

How to use it: Build a state dictionary and a dictionary of questions, then call decide with a workflow name. Each answer comes back as a TypedAnswer. Every option's wording is weighed alongside the workflow state and the question you ask. That makes the schema ordinary data. You can rename an option, change its description or add a question without retraining the model. Questions that sit far from what the model was trained on get shakier answers.

from transformers import AutoModel

model = AutoModel.from_pretrained("mrm8488/embeddinggemma-2-ft-typed-decision", trust_remote_code=True)

state = {
    "agent": {"autonomy": "unsupervised", "model": "internal-agent-v2"},
    "task": "Clean up stale feature branches merged more than 90 days ago.",
    "constraints": ["Never delete anything matching release/*", "Do not force-push to any branch"],
}

questions = {
    "action": {
        "type": "choice",
        "instructions": "What should the observability system do with this trace?",
        "criteria": {
            "continue": "Let the agent proceed without interruption.",
            "observe": "Keep running, but flag the trace for later sampling.",
            "human_review": "Queue this trace for a human to review.",
            "stop": "Halt the agent now.",
        },
    },
    "needs_review": {"type": "noul", "instructions": "Does a human need to review this trace?"},
    "risk": {
        "type": "score",
        "instructions": "How risky is what the agent did?",
        "criteria": ["no risk", "low risk", "significant risk", "severe risk"],
    },
}

answers = model.decide(state, questions, workflow="agent_trace_observability")

TypedAnswer(
    kind="choice",                  # "choice" | "score" | "noul"
    label="human_review",           # the winning option key
    value="human_review",           # typed: str for choice, int for score, bool for noul
    confidence=0.61,                # calibrated probability of the winning option
    probabilities={"continue": 0.02, "observe": 0.11, "human_review": 0.61, "stop": 0.26},
    expected_level=None,            # score questions only: E[level]
)

Question type | Value type | Schema
choice | str | A dictionary of option keys with a description each
score | int | A list of level descriptions, from lowest to highest
noul | bool | Only the instructions, and the answer is true or false with a probability

Tool | What it does
decide | Answers every question in your schema for one state
TypedAnswer | Holds the label, value, confidence and probabilities
to_dict | Turns an answer into JSON

Example: You describe an agent run that tried to clean up branches and broke one constraint, and ask what to do. The card's sample answer shows human_review winning, with the other options listed beside it with their own probabilities.

For newcomers and experts: A good first try is to run the card's example as it is, then change one option description and watch how the probabilities move.

For experts, the head scores the text of every option against the state and the question. That is why the schema is plain data. The confidence is a calibrated probability of the winning option, and score questions also return an expected level. The base model is multilingual, but the head saw only English schemas, so expect softer probabilities in other languages. The tokenizer loads from the same repository on first use.

You describe a state and a schema of questions
The head scores each option's text against them
Probabilities are calibrated for each option
You read typed answers with label and confidence

Good to know:

Title: Model facts
Item | Value
Parameters | 272M
Weights in F32 | about 1.1 GB
Weights at 4-bit | about 136 MB, an estimate
Format | Safetensors
Built on | google/embeddinggemma-2

• Reliability: questions far from the training topics get shakier answers.
• Other languages: the base is multilingual, but expect softer probabilities than in English.
• Oversight: keep a person in the loop for decisions with real consequences.
• License: apache-2.0
• Cost to run: no API key or paid service named.
• Data it reaches: it downloads files from Hugging Face, and the tokenizer from the same repository on first use. The example runs the model on your own machine.
• Not for: free-text answers, or sole control over high-stakes decisions.

On Hugging Face, 13 November 2026

• Task: text classification
• Library: transformers
• Parameters: 272M
• Weights: about 1.1 GB in F32; about 136 MB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 1,800
• Likes: 89
• License: apache-2.0
• Languages: en
• Based on: google/embeddinggemma-2
• Quantized versions: 1
• Fine-tunes: 2
• Tags: transformers, safetensors, gemma_decision, feature-extraction, typed-decisions, structured-decisions, calibration, embeddinggemma, decision-model, text-classification, multilingual

Links

• Model: https://huggingface.co/mrm8488/embeddinggemma-2-ft-typed-decision
• Files: https://huggingface.co/mrm8488/embeddinggemma-2-ft-typed-decision/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download mrm8488/embeddinggemma-2-ft-typed-decision

Then follow the usage in its model card. Nothing in this kit runs by itself.