Small models move to the centre of the agent stack, as d1 adds vision and Beam ships open weights

Liquid AI introduced d1 on 5 October, calling it the company's first decision model and the first to extend decision making to images. The model does not generate tokens. It reads its input in one forward pass and returns a probability for each possible answer, according to the company's blog post. A text decision takes 200 to 300 milliseconds.

That is the pitch: replace a slow, expensive language model call with a fast classifier when the answer is a structured choice. Liquid says d1 matches or beats GPT-6.1 Sol on four of six real applications it tested, from filtering support tickets to inspecting circuit boards, and costs 19x to 200x less than both GPT-6.1 Sol and Claude Opus 5.5. The company also says d1 answers faster on every task. Those comparison numbers come from Liquid's own benchmarks and have not been independently verified.

The timing is not accidental. Across the stack this week, the small, specialised model is being pushed into the places where a general model is too slow or too costly to run.

What a decision model actually buys

Liquid describes three output shapes: a yes/no question answered with a probability between 0 and 1, a choice among labels answered with a probability per label, and a score on a scale. One request can ask several questions about the same state, which cuts the input tokens a system has to pay for. In visual inspection, d1 sorted good and defective parts with 85 to 97 percent accuracy across four production lines: circuit boards, candles, cashews and chewing gum, drawn from the public VisA dataset.

The more interesting detail is that the model was never trained for those tasks. Liquid credits generalisation: the model understands the job from a short written description. In games, adding the screen raised d1's Tetris score from 70 to 81 cleared lines, and in Wordle it read the board from a screenshot and solved 12 of 12 games in an average of 3.8 guesses. On Quick, Draw! it recognised 5.2 of 6 drawings, against 0.6 for random guessing.

One application is aimed squarely at coding agents. In context compaction, d1 reads each tool output in an agent's session and keeps, trims or drops it. Liquid says this removes 52 percent of the tokens while keeping every output the task needs. That is a narrow, repetitive decision that a general model would otherwise make at full price.

The big model that competes on cost per token

The same day, Reflection published details of Beam, its first open-weight model. Beam is a sparse mixture-of-experts model with 501 billion total parameters and 23 billion active. Reflection says it pretrained Beam on 23.8 trillion tokens and ran a high-compute reinforcement learning phase that generated over 100 million rollouts on 10.5K NVIDIA GB300 GPUs across four weeks.

The weights are not out yet. Reflection says Beam is in final red-teaming and evaluation, with weights, a technical report, a model card and developer artifacts promised later this month. Early access is by sign-up. So every benchmark number in the announcement is the company's own.

Read those numbers carefully, because they cut both ways. On SWE Bench Pro v2-Hard, Reflection reports Beam at 77.2 against 88.2 for Kimi K3 and 84.3 for GLM 5.3. On Terminal Bench v2.1 it reports 80.1, against 88.3 for Kimi K3 and 88.2 for GLM 5.3. On SWE Bench Pro v1 it reports 65.5, against 67.7 for Qwen 3.8 Max. Beam does not lead.

Reflection's argument is efficiency, not raw capability. The company says Beam reaches scores comparable to GLM 5.2 while using 3 to 4 times less inference compute, and that the gap widens against models in the 2T+ parameter family. On HLE without tools, Beam scores 36.2 against 46.9 for Kimi K3 and 43.6 for Qwen 3.8 Max; with tools it scores 51.2 against 62.5 for GLM 5.3 and 63.9 for DeepSeek V4.1 Flash. Reflection states plainly that frontier open models like Kimi K3 remain ahead on raw capability.

Small models running next to big ones

The most concrete demonstration of the small-model thesis this week comes from an unexpected place: a coding agent on GitHub called Jeff-Code. It puts a 0.8B decision model inside the agent loop of Pi, the coding agent by Mario Zechner and contributors, working alongside Qwen 3.8-27B.

Around each Qwen turn, Jeff makes two decisions, roughly 0.2 seconds each. Can it take the next step itself, such as reading a file, listing a folder, searching code or running tests? And does Qwen need to think hard on this turn? Writing and editing files always stay with Qwen, and Jeff hands over whenever it is unsure.

The results, from the project's own paired evaluation, are unglamorous and worth reading. Pass rate came in at 62.4 percent for Jeff-Code against 62.8 percent for Qwen alone, a paired difference of minus 0.2 points across 1,242 paired tasks. Average time per task fell to 0.68x, a geometric mean of per-task ratios with a 95 percent interval of 0.64 to 0.72. Total time across all tasks dropped less, to 0.86x, because in about 5 percent of tasks Jeff-Code ran more than 30 minutes longer than Qwen alone.

The headline claim is 47 percent faster, or 32 percent less time, at the same pass rate. The detail matters more than the headline: no clear speed-up on Terminal-Bench 2.0 (0.96x) or SkillsBench (0.91x). Turning thinking off on every turn is faster still, but costs 7.6 points of pass rate. A less cautious Jeff, at a threshold of 0.7, costs 4.5 points. Small models here are a scheduling layer, not a substitute for the big one.

Where the small model still strains

A second GitHub project, Reika, is a coding agent CLI built around small local models first: 8B to 35B parameters, often at Q2 to Q4 quantisation, on a 16 to 32k context window. Its author publishes the findings, and they are candid about the limits. In testing, 14 to 35B models handled multi-file tasks most reliably, 8 to 9B models managed simple, well-scoped ones, and below 7B rarely got far. The project is pre-1.0 and says commands and behaviour can still change.

The harness numbers are the useful part. One mid-context rewrite re-processed 8,453 tokens of prompt, or 7.9 minutes of prefill, where an append in the same session cost 25 tokens and 3.5 seconds. Prompt wording is described as the weakest lever: on a vague task at Q2, a model converges or spirals about 50/50, and the harness cannot move that rate, only what the failing half costs. Reika's own conclusion is that it does not make a small model smarter, it makes working with one less frustrating.

Hardware is moving in the same direction. Interfaze 1.1 Lite, published on Hugging Face on 5 October, is a mixture-of-architectures model that pairs a reasoning core with specialist components for documents, speech, visual grounding and structured output. The whole thing runs on one 80 GB GPU with no external services. It is not a single network: the core plans, calls specialists and composes the answer from what they return.

Its benchmarks are a reminder that small and single-GPU do not mean weak. Interfaze 1.1 Lite reports 85.9 on GPQA Diamond, against 92.4 for Interfaze, 82.8 for GPT-5.4-Mini, 89.9 for Claude-Sonnet-4.6 and 88.5 for Gemini-3-Flash. On MMMU-Pro it reports 73.2, ahead of Interfaze at 71.1. On speech recognition, measured as word error rate on VoxPopuli-Cleaned, it reports 3.01 against 2.4 for Interfaze and 4.0 for Gemini-3-Flash. Interfaze also says a 95-minute recording transcribes in about 90 seconds.

Why this matters for buyers

The practical change is that teams now have three separate cost levers, and they are being sold as one story. A decision model can absorb a repetitive call. A small model can schedule or route work around a large one. A dense or sparse large open-weight model can be tuned for inference efficiency rather than benchmark leadership. Each lever has a published number attached, and almost all of those numbers come from the vendor.

The unknown is reliability outside a demo. Reika's findings show that a small model takes tool output literally: a grep that returned "0 matches" for a call it could not serve sent a model rewording a correct pattern for five rounds. Jeff-Code shows that per-task speed-ups can be eaten by a long tail of tasks that run far slower. Liquid's accuracy figures come from a small set of applications and datasets. None of these projects has published an independent audit.

There is one more signal worth watching. Sean Goedecke argued on 5 October that models like Jev, which he calls System One classifiers, can be replaced by hand-built classifiers trained on their own input and output logs. Once a team has validated a prompt-driven decision, collecting the data and training a specific model is a well-understood problem, he writes. If that pattern takes hold, today's decision models are a stepping stone to something cheaper, and the pricing pressure runs one way.

For now, the dates to hold onto are these. Liquid's d1 is available today at console.liquid.ai. Reflection says Beam's weights arrive later this month, with no date given. Jeff-Code and Reika are both public on GitHub, both pre-1.0, both measuring their own harnesses. The small model is no longer a demo category; it is a line item.