Instructions to use jgeuter/Jeff-1.0-Medium with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use jgeuter/Jeff-1.0-Medium with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("text-generation", model="jgeuter/Jeff-1.0-Medium")
messages = [
    {"role": "user", "content": "Who are you?"},
]
pipe(messages)

# pip install -U transformers accelerate
# Load model directly
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("jgeuter/Jeff-1.0-Medium")
model = AutoModelForCausalLM.from_pretrained("jgeuter/Jeff-1.0-Medium", device_map="auto")
messages = [
    {"role": "user", "content": "Who are you?"},
]
inputs = tokenizer.apply_chat_template(
	messages,
	add_generation_prompt=True,
	tokenize=True,
	return_dict=True,
	return_tensors="pt",
).to(model.device)

outputs = model.generate(**inputs, max_new_tokens=256)
print(tokenizer.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use jgeuter/Jeff-1.0-Medium with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "jgeuter/Jeff-1.0-Medium"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "jgeuter/Jeff-1.0-Medium",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker

docker model run hf.co/jgeuter/Jeff-1.0-Medium

SGLang

How to use jgeuter/Jeff-1.0-Medium with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "jgeuter/Jeff-1.0-Medium" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "jgeuter/Jeff-1.0-Medium",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "jgeuter/Jeff-1.0-Medium" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "jgeuter/Jeff-1.0-Medium",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Docker Model Runner
How to use jgeuter/Jeff-1.0-Medium with Docker Model Runner:
```
docker model run hf.co/jgeuter/Jeff-1.0-Medium
```

Jeff-1.0-Medium

Jeff-1.0-Medium is a Jev-style decision model: a state, a typed question, and its options go in, and one forward pass returns a calibrated probability for each option. Nothing is generated. It is Gemma 4 12B (instruction-tuned) with a LoRA adapter merged into the weights and a small decision head, trained with cross-entropy for 400 steps. It belongs to the Jeff 1.0 models; the largest is Jeff-1.0-Large (Gemma 4 31B).

Serving code (repository "Jeff", Docker, TypeSafe "System One" request format as used by JevBench): https://github.com/j-geuter/Jeff, release v1.1.1
Model collection: https://huggingface.co/collections/jgeuter/jeff-10

Use

hf download jgeuter/Jeff-1.0-Medium --local-dir /models/Jeff-1.0-Medium
git clone --branch v1.1.1 https://github.com/j-geuter/Jeff && cd Jeff
docker build -t jeff . && docker run --gpus '"device=0"' -v /models/Jeff-1.0-Medium:/model:ro -p 127.0.0.1:8013:8013 jeff

One GPU with at least 40 GB (bf16 weights are about 24 GB). The model needs to be served through the serving code (see above).

What is in this repository

File	Content
`model-*.safetensors`, `config.json`, tokenizer files	Gemma 4 12B text model (bf16) with merged LoRA adapter
`head.safetensors`, `head_config.json`	decision head
`serving_rule.json`	per-type temperatures (choice 1.19, yes/no 1.13, score 1.13)
`jeff_config.json`	base model and revision, training run, prompt format, input limit
`SHA256SUMS`	checksums of all files

How it decides

Each question is rendered as a multiple-choice prompt (SemIf's template: a short system message and a JSON object with the state, the question, and the options labeled A, B, C, ...; Gemma's chat template, thinking disabled). The model reads it once. The head maps the last hidden state to one logit per option. The serving rule divides the logits by one temperature per question type (fitted on validation data, never below 1).

Question types: choice (2 to 16 options), yes/no, score (2 to 16 ordered levels). Inputs up to 8,192 tokens.

Training

LoRA rank 32 (alpha = 64) on all attention and MLP projections, trained jointly with the head. No reinforcement learning, reward model or auxiliary loss. For more training details, please see our paper: https://arxiv.org/abs/2610.17205.

Disclosure. No JevBench item (public or sealed) was used for training, model selection or calibration. The 231 public JevBench items were used only as an evaluation check. The recipe and the seed (seed 1 of three: 75.6, 74.6, 74.8) were chosen on OpenDecisions, our own validation set of 2,352 decisions.

Evaluation

	Jeff-1.0-Medium	Gemma 4 12B, zero-shot letter readout	Jev 1.13.0 (API)
OpenDecisions Capability, (Intelligence + Calibration) / 2	75.6	75.4	80.1
Seven public held-out decision datasets, macro accuracy (%)	87.6	87.8	88.0
same, mean ECE (lower is better)	0.070	0.080	0.066

OpenDecisions is scored without JevBench's yes/no abstention band. The seven public sets are TREC, CB, WANLI (256 items), SemIf's authored and perturbation sets, TypeSafe's example set and decider's held-out tasks (9,212 items); none of them were in the training pool. See the paper for more details.

Limitations

At most 16 options per question; inputs above 8,192 tokens are refused.
Mostly English training data (OpenDecisions is 78% English).
On knowledge-heavy multiple-choice (MMLU-Pro, MMLU, WinoGrande), Jev is still ahead by 4 to 5 points.
Probabilities are calibrated on our validation data; recalibrate for a very different domain.

Licence

The weights are released under CC BY-NC 4.0 (non-commercial). They are derived from google/gemma-4-12B-it (Apache License 2.0), and the training data includes sources with non-commercial terms (see the table above). The serving code is Apache-2.0.

Citation

If you find this model helpful, please consider citing our paper:

@misc{geuter2026releasinginnerjevsimple,
      title={Releasing the Inner Jev: A Simple Recipe for Open Decision Models}, 
      author={Jonathan Geuter and Andrew Cheng and David Alvarez-Melis},
      year={2026},
      eprint={2610.17205},
      archivePrefix={arXiv},
      primaryClass={cs.AI},
      url={https://arxiv.org/abs/2610.17205}, 
}