Embedders, Deciders, Generators: The Agent Stack Goes Open

Six days into October, four teams shipped models that would each have been a week's headline on their own. Google released EmbeddingGemma 2, a 740M multimodal embedder. AWS's Strands Labs open-sourced Decider 2B, a model that cannot write a word. Cloudflare followed a day later with Clef, a 27B decision model hosted at the edge. And Aleph Alpha published Kolibri-1's weights on Hugging Face — a 78B-parameter sovereign MoE that activates only 3.46B per token.

Different sizes, different jobs, one shared conviction: the era of one general-purpose model doing everything is giving way to specialised components — an embedder, a decider, a generator — each sized to its job, each Apache 2.0.

EmbeddingGemma 2: One Vector Space, Pay-Per-Modality

EmbeddingGemma 2 maps text, code, images, video, and audio into a single 768-dimensional space. The architecture is modular: a 270M text backbone (an adapted Gemma 4 decoder), plus optional vision (170M) and audio (300M) encoders. You load only what your workload needs:

from sentence_transformers import SentenceTransformer

MODEL_ID = "google/embeddinggemma-2"

# Text + code only: 270M parameters
text_model = SentenceTransformer(
    MODEL_ID,
    config_kwargs={"vision_config": None, "audio_config": None},
)

# Full multimodal: 740M parameters
model = SentenceTransformer(MODEL_ID)

The headline number is a 9.92-point jump on MTEB Code (68.76 → 78.68 NDCG@10) over EmbeddingGemma 1, while multilingual text performance holds steady (61.15 → 61.36 on MTEB v2). For anyone indexing codebases for retrieval-augmented coding agents, that is the difference between a demo and a product.

The model is trained with Matryoshka Representation Learning, so you can truncate the 768-dimensional output to 512, 256, or 128 dimensions and keep most of the quality — 256d retains a 60.41 MTEB score against 61.36 full-size. When truncating, re-normalise (normalize_embeddings=True). One caveat from the docs: activations are incompatible with float16 — use bfloat16 or float32.

Because EmbeddingGemma 2 shares its tokenizer and audio encoder architecture with Gemma 4, the intended pairing is on-device RAG: a sub-1B embedder and a small generator sharing memory rather than competing for it.

The Decision-Model Wave: Two Releases, One API

The sharpest signal this week came from two decision models arriving within 24 hours of each other — and speaking the same protocol.

Strands Decider 2B takes Qwen3.5-2B-Base, removes the language-model head, and attaches a ~1M-parameter pointer head with a rank-16 LoRA on the torso. It cannot generate text. Instead, it answers typed questions — noul (true/false), choice, score — returning a calibrated probability per option in a single forward pass, in tens of milliseconds on commodity hardware. AWS published the weights, all training data, and 19 documented recipe versions. On JevBench it scores 100% on easy tasks, placing second among same-size public models and first among those shipping a full training recipe.

Cloudflare's Clef scales the same idea to 27B. Post-trained from Qwen3.8-27B with its vision encoder intact, Clef reads state as text, JSON, images, or video, and scores every option of every question jointly via a transformer head that routes evidence from the state to each question. It currently leads the Jev Decision Index and serves from Workers AI GPUs at the edge, with a 9B Clef-flash variant for hot paths.

	Strands Decider 2B	Clef	Clef-flash
Base	Qwen3.5-2B	Qwen3.8-27B (vision)	9B
Context	4K	64K	64K
Vision	—	✓ (4 images)	✓
Questions/request	typed (noul/choice/score)	up to 64	up to 64
Hosting	local CPU/GPU	Workers AI, $0.24/M input	Workers AI
Recipe	full data + scripts published	RL fine-tuning platform	—

Neither model is the story. Both implement the Jev/SystemOne API (POST /v1/systemone): within a month of TypeSafe's Jev introducing the pattern, decision models have an emerging wire format. That is how infrastructure standards form — not by committee, but by the second and third independent implementation.

What a decision model is actually for

AWS's worked example gates a tool call before it executes. A Strands agent with an over-eager weather tool guesses a city when the user didn't name one; the decider reads the conversation and the proposed call, and answers two yes/no questions — are these arguments grounded in anything the user said, and is it too early to call this tool?

class ToolCallGate(InterventionHandler):
    def before_tool_call(self, invocation, tool, args):
        decision = decider.ask(
            state=invocation.conversation,
            questions={
                "grounded": noul("Are the arguments grounded in user input?"),
                "too_early": noul("Is it premature to call this tool?"),
            },
        )
        if decision.answers["grounded"].probability < 0.5:
            return Guide(feedback="Ask which city the user means.")
        return Proceed()

The InterventionHandler contract returns typed actions — Proceed, Deny, Confirm (escalate to a human), or Guide (hand the turn back with feedback). Because the decision costs single-digit milliseconds rather than an LLM round-trip, it can sit in the hot path of every tool call. The model card is honest about limits: calibration is domain-limited, and long multi-step questions remain a weak spot.

Kolibri-1: The Generator, Sovereign and Sparse

The generation slot in the stack goes to Aleph Alpha's Kolibri, whose weights landed on Hugging Face as Aleph-Alpha/Kolibri-1 (78.9 GB, 32 safetensors shards) on 2 October.

The architecture is aggressively sparse: 78.1B total parameters across 384 routed experts (6 active per token plus one shared), 50 blocks mixing sliding-window attention (512 tokens) with full attention every fifth layer, and a 128K vocabulary. At 3.46B active parameters per token — 4.4% of the model — it targets the Pareto frontier of quality and serving cost in both English and German among the open models Aleph Alpha evaluated.

Two numbers matter more than the architecture. German accounts for over 20% of the 24T-token training mix, with more than 2T German tokens curated and synthesised in-house. And the context window reaches 1M tokens, with reasoning effort set per request (none, low, medium, high) to trade latency against quality. Serving runs through Aleph Alpha's vLLM plugin:

pip install "aleph-alpha-inference>=1.0"

vllm serve Aleph-Alpha/Kolibri-1 --kv-cache-dtype fp8 \
  --reasoning-parser kolibri1 \
  --tool-call-parser kolibri1 \
  --enable-auto-tool-choice

Recommended sampling: temperature=1.0, top_p=0.97, top_k=128. Beyond 262K tokens you need --max-model-len 1048576 plus a max_position_embeddings override.

The community reaction tells the practical story: the first Hugging Face discussion is a request for MLX and GGUF quants, because FP8 weights at 78 GB do not fit a 64 GB Apple Silicon machine. Community quants appeared within two days — the 2.5–4-bit range brings Kolibri to 26–39 GB — but the official pipeline assumes an operator with a real GPU, which fits its intended customers: public administration, industry, and aerospace, running under GDPR and the EU AI Act on infrastructure they control.

One licence nuance is worth reading before you build on it: Apache 2.0 covers the weights and configuration files in the repository; Aleph Alpha explicitly retains rights to the architecture, training methods, and tooling around them.

The Pattern: Assemble, Don't Monolith

Put the four releases side by side and an agent architecture falls out:

Stage	Model	Size	Latency	Licence
Embed	EmbeddingGemma 2	270M–740M	on-device	Apache 2.0
Decide	Strands Decider 2B / Clef	2B / 9B / 27B	ms	Apache 2.0
Generate	Kolibri-1	78B (3.46B active)	batch	Apache 2.0

Retrieval runs locally on the embedder. Every tool call, guardrail check, and routing decision passes a decider that answers in milliseconds with a probability, not a paragraph. The generator — the expensive part — is invoked only when something genuinely needs writing. Each component is open enough to swap, benchmark, or fine-tune independently, and the decision layer already has a de facto standard API.

That is the real news of this week: not any single model, but that the boring middle of the agent loop — the parts nobody demoed in 2024 — now has open, specialised, interchangeable parts.

Try them: EmbeddingGemma 2 on HF · Strands Decider repo · Clef on Workers AI · Kolibri-1 weights