This was the week the parameter count orthodoxy died. Nobody wrote a press release. Nobody announced it. It just happened, quietly, across a dozen Hugging Face uploads and three Reddit threads.

For three years everyone operated under one unchallenged rule: bigger model = better at everything. This week that rule broke. Not in theory. In measurable, downloadable, run-on-your-laptop practice.

The 4B model that beat 30B

Last week Apodex uploaded a 4 billion parameter fine tune. It beat every open 30B class model on web research benchmarks. Not tied. Beat.

This is not a trick of benchmark gaming. The model does not memorize answers. It goes out, fetches pages, cross references claims, corrects its own mistakes and returns a cited answer. It does this better than models eight times its size.

The authors did not invent a new architecture. They did not add more compute. They did two simple things: they trained the model explicitly to verify its own work before outputting an answer, and they built training data that rewarded that behaviour over raw speed of generation.

This is not an outlier. This is the new baseline. For any narrow, well defined task, a properly trained small model will now outperform a generic large model. This was always true in theory. This week it became true for something people actually use.

You will not see this result on the general purpose leaderboards. Those are still calibrated for generic capability. For anyone building actual production systems, this result changes every calculation you have been making.

GLM 5.2 landed, and nobody is talking about the license

GLM 5.2 dropped this week. It is the best open model ever released. It matches or beats every closed frontier model on half the published benchmarks. And it is MIT licensed.

No usage restrictions. No geographic blocks. No royalties. You can run it, modify it, fine tune it, sell services on top of it. Nobody can take this away from you.

That fact is more important than any benchmark number. For the first time, there exists a frontier capability model that is actually, properly open. Not open with asterisks. Not open for non commercial use only. Open.

Unsloth published GGUF quantizations within 12 hours. As of writing you can run the Q4_K_M quantized version on any machine with 32GB of RAM. You can run the 2 bit version on a 16GB laptop. It will be slow. It will work.

The IndexShare architecture this model uses cuts per token FLOPs by 2.9x at 1M context length. This is not an incremental improvement. This is the single largest inference efficiency gain we have seen in a flagship model in 18 months.

Laguna M.1 and the quiet MoE standardization

Poolside released Laguna M.1 this week, a 225B MoE with 23B activated parameters. It is Apache 2.0 licensed.

The most interesting thing about this model is how uninteresting the architecture is. There are no novel tricks. No secret optimizations. They just built a very solid, very conventional MoE, trained it well, and released it properly open.

This is the sign that MoE has matured. Nobody is arguing about routing algorithms any more. Nobody is debating top-k values. Everyone has converged on roughly the same design. The experimentation phase is over. MoE is now just standard engineering.

Laguna lands almost exactly at the top of the open coding leaderboards. It will not make headlines. It will be used in production by thousands of teams before the end of the month.

The missing middle class of models

There is now a very obvious gap in the open model ecosystem.

On one end you have excellent 3B, 7B, 27B models. On the other end you have 225B, 355B flagship models. There is almost nothing usable between 40B and 180B.

This is a problem. Millions of users have hardware that sits exactly in this gap. Apple Silicon machines with 96GB, 128GB unified memory. Ryzen AI workstations. Multi 3090 setups. DGX Spark nodes. All of these can run a 80-120B model perfectly well. None of them can run GLM 5.2 at usable speed.

All of the major labs are skipping this size class entirely. They are optimizing either for consumer GPUs with 16-24GB VRAM, or for datacenter deployments with 80GB A100s. Nobody is building for the hundreds of thousands of engineers with mid tier workstation hardware.

This is the single largest unmet demand in the community right now. The first lab that releases a good 110B open model will own this entire segment for six months.

Distillation is now the community's most important project

Within 24 hours of GLM 5.2 being released, the top request on /r/LocalLLaMA was for someone to generate a distillation dataset.

This is how progress works now. The big labs train the flagship model. The community extracts the capability, distills it down into smaller sizes, and makes it usable for everyone. This process now takes weeks, not months. Soon it will take days.

Nobody is waiting for official small versions any more. The community does not trust the labs to make good small models. They know they can do a better job themselves, given the teacher model and enough compute.

This is the open source advantage that closed models will never be able to match. Every time a new frontier model is released, it becomes the teacher for an entire generation of smaller, faster, cheaper models that run on every piece of hardware ever made.

Vibe coding is the new fine tune standard

Nobody is writing instruction datasets by hand any more.

The Vibe-Coding-Instruct dataset uploaded this week is 25.5 million tokens of high quality engineering planning examples. Every entry follows exactly the same structure: problem statement, structured implementation plan with milestones, risks, testing strategy and scaling considerations.

It is boring. It is repetitive. It is exactly what models need to learn to produce usable output instead of clever nonsense.

This dataset already has three fine tunes built on top of it. They all produce vastly more practical engineering output than any of the general purpose coding models. Nobody won a benchmark with this. Everyone building actual tools is already using it.

The best training datasets are no longer the ones with the most variety. They are the ones with the most consistent structure. Models do not need surprise. They need pattern.

Tiny models are no longer toys

Inflect-Nano dropped this week. It is a working TTS model with 4.63 million parameters.

That is not a typo. 4.63 million. Not billion. Million.

It runs on anything. It will run on a microcontroller. It will run in a browser tab. It is 17 times smaller than Kokoro. It is almost 1000 times smaller than the current frontier TTS models.

It does not sound perfect. It sounds good enough for a lot of use cases. And that is the point. We are now exploring the absolute lower bound of how small a model can be and still do useful work.

Nobody is trying to beat SOTA any more. People are trying to find the floor. And every week that floor gets lower.

Agents are now training other agents

SakanaAI uploaded the AI CUDA Engineer Archive this week. It contains 14,000 complete runs of an agent writing, testing, profiling and optimizing CUDA kernels. Every entry has working code, runtime measurements, NCU profiles, clang tidy output and pass/fail validation.

This is not human generated data. This is agent generated training data.

This is the next loop. Agents solve problems. We record every step they took, every mistake they made, every correction they applied. We then train new agents on that trace data. Those new agents are better, faster and cheaper than the original.

This loop has already started. Nobody knows how far it goes.

Web inference hit 250 tokens per second

Gemma 4 is now running in browser at 255 tokens per second on M4 Max hardware.

The kernels that made this possible were not written by Google engineers. They were written by Fable 5, the Claude Code agent. The agent iterated on the kernels, profiled them, adjusted memory access patterns and unrolled loops until it hit this speed.

This is not a demo. You can go run it right now in your browser. No installation. No downloads. Just click the link.

Inference performance is no longer limited by human ability to write optimized kernels. It is limited by how long you let an agent iterate on the problem.

What comes next

We have crossed an inflection point. Raw parameter count is no longer the primary driver of capability. Training method and data quality are now more important.

This changes everything. Progress will not slow down. It will accelerate. You no longer need a billion dollar compute cluster to make a better model. You just need a good idea about how to train the ones we already have.

The labs will keep releasing bigger flagship models. That is what they know how to do. But all of the actual useful progress from this point on will happen in the community, with small models, with distillation, with training data built from agent traces.

Nobody is in control of this any more. That is the good part.