DiffusionGemma as a local Jev

DiffusionGemma is Google's open-weight, text-diffusion model — and because it denoises a whole token canvas in parallel, people constrain it into a fast, local, Jev-like decision engine. It's the diffusion route to self-hosted typed decisions, and it's genuinely experimental.

What DiffusionGemma is

DiffusionGemma is an experimental open-weight model (Apache 2.0) in Google's Gemma family, released June 2026. It's a 26B-A4B mixture-of-experts (8 active experts of 128) that generates text by diffusion — filling a canvas of placeholder tokens and refining them in parallel over denoising passes, roughly 4× faster decoding than autoregressive Gemma. It's multimodal on input (text, image, video) and runs locally in around 18 GB of VRAM.

Relationship to official Jev

DiffusionGemma is a general Google model, not a decision model and not TypeSafe's Jev. The "as Jev" pattern repurposes it: a typed decision needs one structured answer, not left-to-right generation, so you constrain the canvas to a fixed set of options and read the choice in a single pass. It's a technique, not a calibrated decision model — see DiffusionGemma vs Jev for the full comparison.

Requirements

• An NVIDIA GPU (~18 GB VRAM) or Apple Silicon via MLX.
• A runtime with structured / constrained generation: vLLM (structured-generation support), MLX, or HF Transformers.
• The open weights: google/diffusiongemma-26B-A4B-it on Hugging Face.

The approach (constrain the canvas to a decision)

There's no turnkey Jev server here — you drive the base model with constrained decoding. Load DiffusionGemma in vLLM or MLX, pose the decision as a prompt whose answer must be one of your candidate labels, and use the runtime's structured-generation / grammar constraint so the parallel decode can only emit a valid option. You then read the option (and, if exposed, its score) as your decision.

# Sketch — vLLM with structured generation (see vLLM's DiffusionGemma support)
# pip install vllm && download google/diffusiongemma-26B-A4B-it
#
# Serve the model, then constrain generation to your candidate set
# (guided_choice / grammar) so one denoising pass returns exactly one label:
#   choices = ["billing", "bug", "other"]
#   out = llm.generate(prompt, guided_choice=choices)
#   decision = out[0].outputs[0].text   # one of choices, nothing else

Local API endpoint

vLLM serves an OpenAI-compatible HTTP API, so you get a local endpoint — but it's a chat/generation endpoint you constrain, not a native Jev decision contract. If you need the exact Jev request shape locally, OpenJev or a Laya wrapper is a closer fit; DiffusionGemma-as-Jev is more of a build-it-yourself decision layer on a fast diffusion base.

Reported latency

Google reports diffusion decoding roughly 4× faster than autoregressive Gemma, thanks to the parallel canvas pass. But end-to-end decision latency depends on your hardware, quantization and the constraint overhead, and it hasn't been benchmarked for typed decisions specifically — measure it yourself.

Calibration caveats

This is the least drop-in and least calibrated of the local routes: it's a general model bent into the decision role, so any confidence you read is not trained-for-decisions calibration. It also trails standard Gemma 4 on most benchmarks (Google frames the trade as worth it for infilling / inline editing). Validate heavily before using it for anything with a threshold.

Sources

• ai.google.dev — DiffusionGemma docs — Google model docs
• Hugging Face — google/diffusiongemma-26B-A4B-it — open weights

Structured-generation support is landing in vLLM (and the model runs in MLX / HF Transformers). Everything here is fast-moving — check current runtime docs.

See also: DiffusionGemma vs Jev (full comparison) · Jev on Hugging Face · ← Compare all local Jev alternatives · Prefer hosted Jev (no GPU)

Other local models: Laya · NanoJev · OpenJev