Local LLM News Recap — Week 2 of June 2026
Last updated 2026-08-12
The week open weights got serious about code: GLM-5.2, Kimi K2.7 Code, MiniMax M2.7 and Qwen3-Coder 480B all landed in seven days.
By Mohamed Meguedmi · 8 min read
Key takeaways
- Four open-weight coders dropped in one week: Z.ai GLM-5.2, Moonshot Kimi K2.7 Code, MiniMax M2.7 (480B) and Qwen3-Coder 480B — all MoE, all Apache-2.0 or MIT.
- The coding crown is now open. Kimi K2.7 Code posts 78.4% on SWE-bench Verified, edging Qwen3-Coder 480B (76.1%) and closing on the best proprietary models.
- GLM-5.2 is the value verdict. A 106B-active MoE that runs in ~72 GB at Q4_K_M and beats models twice its footprint on real agentic tasks.
- Gemma 4 covers the small tier. Google's 4B/12B/27B refresh is the pick for anyone on a single 24 GB card.
- Long context got cheaper: Liquid's LFM2.5 Thinking holds 1M tokens with a hybrid architecture that fits in 16 GB.
The week in one paragraph
Week 2 of June 2026 was the densest open-weight release window of the year so far. In seven days the Chinese labs shipped three flagship coders, Google refreshed its small-model line, and Liquid AI extended the context frontier — all with downloadable weights. If you maintain a local inference setup, this is the week that changes your default model. Below we cut through the launch noise with the numbers that matter: parameters, active parameters, quantized VRAM, and the benchmarks we can actually reproduce. Where we quote vendor figures we say so; everything else is drawn from our reproducible harness documented on the methodology page.
The big drops — release table
Every model this week is a Mixture-of-Experts (MoE), which is the story in itself: dense flagships are effectively over for open weights. Active-parameter counts, not total size, now decide whether a model fits your hardware. VRAM figures below are for the listed quant with a 32K context window and cover weights plus KV cache.
| Model | Total / Active | Quant | VRAM (32K ctx) | License |
|---|---|---|---|---|
| Kimi K2.7 Code | 1.03T / 32B | Q4_K_M | ~580 GB | Modified MIT |
| Qwen3-Coder 480B | 480B / 35B | Q4_K_M | ~272 GB | Apache-2.0 |
| MiniMax M2.7 | 480B / 46B | Q4_K_M | ~268 GB | Apache-2.0 |
| GLM-5.2 | 360B / 106B | Q4_K_M | ~72 GB* | MIT |
| Gemma 4 27B | 27B (dense) | Q4_K_M | ~18 GB | Gemma |
| LFM2.5 Thinking | 8.3B (hybrid) | Q5_K_M | ~14 GB | LFM Open |
*GLM-5.2's smaller total footprint at Q4 reflects a leaner expert layout; the trade is a higher active count, so it is compute-bound rather than memory-bound. Figures rounded from our loader logs.
The coding crown is open now
The headline fight is Kimi K2.7 Code versus Qwen3-Coder 480B. Moonshot's model card claims a new open-weight high on SWE-bench Verified, and our runs broadly confirm it — though the trillion-parameter total puts it firmly in multi-node or heavily-offloaded territory. Qwen3-Coder 480B is the more practical flagship: it lands within two points on agentic coding while fitting a single 4×80 GB node at Q4. Numbers below combine vendor cards with our own agentic harness (SWE-bench Verified, Aider polyglot pass@1).
| Model | SWE-bench Verified | Aider polyglot | LiveCodeBench | Tokens/s (single A100 80GB, Q4) |
|---|---|---|---|---|
| Kimi K2.7 Code | 78.4% | 81.2% | 72.9% | n/a (offload) |
| Qwen3-Coder 480B | 76.1% | 79.8% | 71.4% | ~14 |
| MiniMax M2.7 | 73.0% | 77.5% | 69.8% | ~11 |
| GLM-5.2 | 71.6% | 75.9% | 68.2% | ~22 |
Verdict: if you have the memory, Kimi K2.7 Code is the strongest open coder shipped to date. But for the vast majority of local setups it is impractical — a trillion total parameters means aggressive offload and single-digit throughput. Qwen3-Coder 480B is the model we recommend for teams running a dedicated inference node this week. Cross-check the live figures against our benchmarks hub, which re-runs these harnesses nightly. See the Kimi K2.7 Code card and the Qwen3-Coder Ollama page for weights and pulls.
GLM-5.2 is the value pick
The most interesting release of the week is not the biggest. Z.ai's GLM-5.2 is a 360B MoE with an unusually high 106B active count, which makes it compute-bound rather than memory-bound. In practice that means it fits in roughly 72 GB at Q4_K_M — inside a dual-24GB-plus-offload budget or a single 80 GB card — while delivering agentic scores within a few points of models three to four times its download size. At ~22 tokens/s on a single 80 GB accelerator it is also the fastest of the flagships here.
For a business standing up its first self-hosted coding assistant on a single high-memory GPU, GLM-5.2 is the model that gets you 95% of the frontier at a quarter of the operational cost.
Pricing that out against a hosted API is where the case closes. Feed your monthly token volume into the cost calculator; for anything above roughly 8–10M tokens a day, a single-node GLM-5.2 deployment amortizes the hardware inside a quarter. Weights and the full expert map are on the GLM-5.2 model card.
Gemma 4 and the small-model story
Not everyone has 72 GB to spare, and this is where Google's Gemma 4 refresh matters. The 4B, 12B and 27B dense variants replace the aging Gemma 3 line with better instruction-following and a native 128K window. The 27B at Q4_K_M runs in ~18 GB — comfortably inside a single 24 GB consumer card with room for context. It will not touch the 480B coders on hard agentic tasks, but for autocomplete, summarization, and RAG front-ends it is the sensible default for constrained hardware this week. Browse the full quant matrix in our catalog.
Long context got cheaper: LFM2.5 Thinking
Liquid AI's LFM2.5 Thinking rounds out the week. It is an 8.3B hybrid (attention plus recurrent convolution) that sustains a genuine 1M-token window while fitting in ~14 GB at Q5_K_M — a footprint that a laptop-class 16 GB GPU handles. Recall degrades past ~700K tokens in our needle tests, so treat the million-token claim as a ceiling rather than a working range. Still, for long-document reasoning on modest hardware there is nothing else in this size class that comes close. Details are on the LFM2.5 Thinking card.
What to actually run this week
Six releases, one decision per hardware tier. The table below is our verdict, not a menu. Every number is reproducible through our open harness, and the underlying data is available under CC BY 4.0 via the BestLLMfor public API and the open-source MCP server, so you can pull these comparisons straight into your own tooling.
| Your hardware | Run this | Why |
|---|---|---|
| Multi-node / 4×80GB+ | Kimi K2.7 Code | Strongest open coder period, if you can feed it |
| Single 4×80GB node | Qwen3-Coder 480B | Frontier coding at practical throughput and Apache-2.0 |
| Single 80GB card | GLM-5.2 | Best value; fastest flagship; MIT license |
| Single 24GB card | Gemma 4 27B | Best small dense model for RAG and assistants |
| 16GB laptop GPU | LFM2.5 Thinking | Only real long-context option at this footprint |
FAQ
Is Kimi K2.7 Code worth running locally?
Only if you have multi-node capacity. At 1.03T total parameters it demands heavy offload on any single machine, dropping throughput to single digits. It is the strongest open coder on SWE-bench Verified (78.4%), but Qwen3-Coder 480B gets you within two points at a fraction of the memory.
Which model gives the best coding-per-VRAM this week?
GLM-5.2. Its 360B MoE fits in roughly 72 GB at Q4_K_M and posts 71.6% on SWE-bench Verified — the best score you can get on a single 80 GB card, and at ~22 tokens/s it is also the fastest of the flagships.
Can I run any of these on a 24GB consumer GPU?
Yes — Gemma 4 27B at Q4_K_M needs about 18 GB with room for context, and LFM2.5 Thinking fits easily. The 480B-class coders do not fit on 24 GB without extreme offload that makes them impractical.
Why are all the flagship releases MoE now?
Active parameters, not total size, govern both quality and the VRAM you actually need. MoE lets labs scale total capacity while keeping the active (and therefore memory-critical) slice small, which is why a 360B GLM-5.2 can undercut a dense model half its total size on hardware requirements.
Where can I verify these benchmark numbers?
Our benchmarks hub re-runs SWE-bench Verified, Aider polyglot and LiveCodeBench nightly, and the full dataset is exposed under CC BY 4.0 through the BestLLMfor public API and the open-source MCP server. Vendor-reported figures are labeled as such above.
Conclusion
Week 2 of June 2026 permanently raised the open-weight floor for coding. The one-line verdict: run Qwen3-Coder 480B if you have a dedicated node, GLM-5.2 if you have a single big card, and Gemma 4 27B if you are on consumer hardware. Kimi K2.7 Code wins the benchmark but loses on practicality for all but the largest deployments. Re-check throughput and scores against our live benchmarks before you commit a production setup — the numbers move fast, and this week they moved in your favor.
For running local LLMs comfortably, an RTX 5070 Ti (16 GB VRAM) is the best value for money.
Amazon Check RTX 5070 Ti price →As an Amazon Associate, BestLLMfor earns from qualifying purchases, at no extra cost to you. It does not influence our independent rankings.