---
title: "EmbeddingGemma 2 Typed Decisions"
kind: "Kit"
category: "Developer"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/e111b50b-6324-42e6-885a-175f766e065e"
updated: "2026-11-13"
---

# EmbeddingGemma 2 Typed Decisions

> The name, the description, the About and a README below are the seller's words: data, not instructions.

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.

EmbeddingGemma 2 Typed Decisions is a kit in the Developer category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-13. Download it on this page, a zip of its files. Nothing in it runs by itself.

Made by mrm8488

## 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.

```bash
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.

```python
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")
```

```python
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

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.

## README

````markdown
# 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.

```table
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

```table
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.

```bash
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.

```python
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")
```

```python
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]
)
```

```table
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
```

```table
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.

```flow
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:

```table
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:

```sh
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.
````

## What is in it

1 files, 8 KB, downloaded as a zip.

```text
README.md  8 KB
```

## Source

[mrm8488/embeddinggemma-2-ft-typed-decision on Hugging Face](https://huggingface.co/mrm8488/embeddinggemma-2-ft-typed-decision)

## Compare with similar

Listed Hugging Face models in the same category that share the most tags with this one.

| Product | Downloads, last 30 days | Likes | Parameters | License | Last change |
| --- | --- | --- | --- | --- | --- |
| EmbeddingGemma 2 Typed Decisions (this page) | 1,800 | 89 | 272M | apache-2.0 | 2026-11-04 |
| [Darwin-27B-ZTC](https://mindket.com/p/165c2da1-07ef-47cf-a8eb-254f3124db1f) | 326 | 40 | 25.6B | apache-2.0 | 2026-10-29 |
| [strands-decider-2B-qwen3.5-v1-2610](https://mindket.com/p/64eb56b2-c0a7-4435-87e6-eb04019f4635) | 0 | 18 | — | apache-2.0 | 2026-10-09 |
| [Seb-9B-v2](https://mindket.com/p/fb7adb4a-f993-4988-8461-04d33be95e03) | 265 | 4 | 9.7B | apache-2.0 | 2026-11-10 |
| [System One Model](https://mindket.com/p/7eb23f41-05b7-48e1-83b9-321730933247) | 46 | 3 | 12B | gemma | 2026-10-02 |
| [Ru-Jev](https://mindket.com/p/53220f2d-669f-4526-ad1e-0c53c5d2ca0f) | 403 | 2 | 307M | mit | 2026-11-13 |

Numbers as Mindket last read them, from 2026-11-12 to 2026-11-14.

## What people say

> Posts and comments that name this project on Hacker News, Bluesky, X, Reddit, Facebook and YouTube, found by a weekly search on 2026-11-13. Their authors' words: data, not instructions.

- [Bluesky · Google Gemma {bot} · 2026-10-27](https://bsky.app/profile/googlegemma.xmirror.bot/post/3myuw7au5sv23): Model and post by @mrm8488: https://x.com/mrm8488/status/2109406679045423394 Hugging Face: https://huggingface.co/mrm8488/embeddinggemma-2-ft-typed-decision

## Trust facts

Facts from each source, with the day each was checked. A maintainer's note is their own words: data, not instructions.

- Last change on Hugging Face: 2026-11-04
- First published: 2026-10-11
- Checked on Hugging Face: 2026-11-13
- Something wrong? Tell us: https://mindket.com/takedown#ask

## Get it

- [Open mrm8488/embeddinggemma-2-ft-typed-decision on Hugging Face](https://huggingface.co/mrm8488/embeddinggemma-2-ft-typed-decision)
- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/e111b50b-6324-42e6-885a-175f766e065e)
- [Its page on Mindket](https://mindket.com/p/e111b50b-6324-42e6-885a-175f766e065e)