mini-Jev

mini-Jev

Picks which tool or action an agent should take by returning a probability for each candidate you supply. An early checkpoint for developers testing tool selection.

Made by samatv256 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: mini-Jev is a small decision model for agents. You pass in the current state, a question and the candidate actions, and it returns a probability for each candidate instead of text. It builds on Qwen3-0.6B, adding a LoRA adapter and a small head that makes the decision, and the card calls it an early checkpoint at 10,626 updates.

Who it suits: Developers building agents that must choose one tool or action from a fixed list are the main fit. Researchers who study small decision models can use the checkpoint too.

Industry | Who uses it | How they use it | Example
Software | Agent developers | Choose which supplied tool to call for a user goal | Pick the weather tool out of three candidate tools
Research | Model researchers | Test early checkpoints of small decision models | Check function-selection accuracy on a held-out set
Automation | Workflow builders | Route a request to one of several fixed actions | Choose the email action for a request to send a message

If you need written answers, tool arguments or huge candidate lists, you can skip it.

Where to use it: Use it in Python scripts on a machine with a suitable GPU.

• Python scripts that import its inference module
• A computer with a CUDA GPU that supports BF16, which the package requires
• Windows, macOS or Linux, for downloading the files with Python

Use case | Who | What they get back
Tool selection | Agent developers | The chosen tool id and a probability for each tool
Action routing | Workflow builders | The best of several fixed actions for a state
Model evaluation | Researchers | Scores to compare against their own held-out choices

How to set it up: You need Python, a GPU and a few downloads.

• Python with pip
• A CUDA GPU with BF16 support
• A connection for the Qwen3-0.6B base model, which downloads separately on first load

1. Install the pinned Hugging Face hub package.
2. Download inference.py and requirements.txt into a working folder.
3. Install the listed requirements.

python -m pip install "huggingface_hub==1.33.0"
hf download samatv256/mini-Jev inference.py requirements.txt --local-dir .
python -m pip install -r requirements.txt

How to use it: Import MiniJev, load the model, then call predict with a state, a question, a question type and your answer options. The script prints the selected id and the scored options.

from inference import MiniJev

model = MiniJev.load()  # Defaults to samatv256/mini-Jev using the HF cache.
result = model.predict(
    state={"user_goal": "Find tomorrow's weather forecast for Paris."},
    question="Given the current state and available options,\nwhich option should be selected?",
    question_type="choice",
    answer_options=[
        {"id": "weather", "type": "tool", "label": "get_weather_forecast",
         "description": "Look up the weather forecast for a place and date."},
        {"id": "invoice", "type": "tool", "label": "calculate_invoice_total",
         "description": "Add amounts on an invoice."},
        {"id": "email", "type": "tool", "label": "send_email",
         "description": "Send an email message."},
    ],
)
print(result["selected_id"])
print(result["options"])

Tool | What it does
MiniJev.load | Loads the adapter, the decision head and the base model
predict | Scores each candidate option for a state and a question
selected_id | Holds the id of the option the model picks
options | Holds the scored list of all candidate options

To pin a release, pass its revision name when you load the model.

MiniJev.load("samatv256/mini-Jev", revision="step-010626")

Example: You pass the goal of finding tomorrow's forecast for Paris, plus three tools for weather, invoice totals and email. The script prints the id of the tool it selected and the list of options with their scores.

For newcomers and experts: Think of it as a picker. You list the choices, and it tells you how likely each one is to be the right next step. A good first try is to download the two files, install the requirements and run the snippet above as it is.

Underneath, the Qwen3-0.6B base model reads the input, and an adapter plus a small head turn that into one score per candidate. Candidate scoring is permutation equivariant, so the order you list candidates in should not change which one wins. The trade-off is scope, since it returns finite-choice probabilities and is weak on large candidate sets.

Pass a state, a question and candidates
The base model and adapter read them
The decision head scores each candidate
Read the selected id and the probabilities

Good to know: The card lists four measured results, and it says their percentages are not directly comparable.

Evaluation | Result | Scope
BFCL V1 Multiple Function adaptation | 96.5% (193/200) | Picks the right function from 2-4 definitions. It is not an official leaderboard score and it writes no arguments or calls.
Strict held-out Choice | 65.6% (63/96) | A balanced slice picked from the validation data, not the whole split.
Bespoke OOD typed decisions | 72.0% (36/50) | A small synthetic check with easy distractors, not a public benchmark.
Typed-decisions full test set | 34.0% (680/2,000) | By type, Choice scored 27.0%, Noul 52.2% and Score 25.6%, so general typed decisions are a weak spot.

• Checkpoint: this is an interim release at 10,626 updates, with training planned through 50,000 updates
• Large sets: a held-out slice with 17 or more candidates scored 4 out of 17
• Old files: model.safetensors and odm_mini.py at the top level come from an earlier version and are kept only for reference
• License: Apache 2.0
• Cost to run: none named. It needs a CUDA GPU with BF16 support
• Data it reaches: the state and options you pass in, plus the base model and files it downloads from Hugging Face
• Not for: generating text or tool arguments, general classification, large candidate sets, or calibrated probabilities in arbitrary domains

On Hugging Face, 13 November 2026

• Library: custom
• Parameters: 263K
• Weights: about 1 MB in F32; about 1 MB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 291
• Likes: 25
• License: apache-2.0
• Based on: Qwen/Qwen3-0.6B
• Tags: custom, safetensors, mini-jev, decision-model, tool-selection, tool-use, agents, action-selection, decision-making, finite-choice, qwen3

Links

• Model: https://huggingface.co/samatv256/mini-Jev
• Files: https://huggingface.co/samatv256/mini-Jev/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download samatv256/mini-Jev

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