Local LLM News Recap — Week 1 of June 2026
Last updated 2026-08-11
Five open-weight releases landed in seven days. Here's what actually runs on your hardware — and which one deserves your download bandwidth.
By Mohamed Meguedmi · 9 min read
Key Takeaways
- Qwen3-Coder 480B (A35B MoE) is the headline drop and now the strongest open-weight coding model you can self-host — but plan on 80GB+ of VRAM, or a 512GB Mac Studio, even at Q4.
- GLM-5.2 Air (106B MoE, 12B active) is the pragmatic winner for most readers: near-frontier reasoning that fits a single 48GB card at Q4_K_M.
- LFM2.5 Thinking is the most practical release of the week — a genuine 256K context window that runs on 12GB and 24GB cards.
- Kimi K2.7 Code and MiniMax M2.7 (480B) raise the high-end MoE ceiling but stay firmly in multi-GPU and server territory.
- Every model here reached Ollama and HuggingFace within 72 hours. Day-one local support is now the norm, not the exception.
The first week of June 2026 was the densest single stretch of open-weight releases we've tracked this year. Five models shipped between June 1 and June 7, four of them Chinese-lab MoE architectures, and — crucially for this audience — every one of them had usable GGUF quants and an Ollama entry within three days. This recap cuts the launch-day noise and answers the only question that matters for a self-hosted setup: what should you actually pull, given the card you already own?
The Week at a Glance
Here is the full slate, ranked by how relevant each is to a single-machine deployment rather than a data-center cluster. Sizes are total parameters with active parameters in parentheses for the mixture-of-experts models. VRAM figures assume the quant we recommend for that model plus a working context window of 16K tokens.
| Model | Params (active) | Recommended local quant | Approx. VRAM | License | Ollama day-one |
|---|---|---|---|---|---|
| LFM2.5 Thinking | 8B dense | Q5_K_M | ~7 GB | LFM Open | Yes |
| GLM-5.2 Air | 106B (12B) | Q4_K_M | ~62 GB | MIT | Yes |
| Qwen3-Coder 480B | 480B (35B) | Q4_K_M / dynamic Q2 | ~270 GB / ~150 GB | Apache 2.0 | Yes |
| MiniMax M2.7 | 480B (~46B) | Q4_K_M | ~260 GB | MIT | Yes |
| Kimi K2.7 Code | 1T (32B) | Q2_K_XL | ~340 GB | Modified MIT | Yes |
The spread tells the story of the whole week: two releases (LFM2.5 and GLM-5.2 Air) are built for hardware normal people own, and three are frontier-scale MoEs that only make sense on multi-GPU servers or high-memory Apple Silicon. We'll treat those two groups differently, because they serve completely different readers.
Qwen3-Coder 480B: The New Open-Weight Coding Ceiling
Alibaba's Qwen3-Coder 480B-A35B is the most important release of the week on raw capability. On the Aider polyglot coding benchmark it posts 71.4%, edging past the previous open-weight leader and landing within striking distance of closed frontier coders. HumanEval saturates at 96%+, which is no longer a meaningful signal — Aider polyglot and SWE-bench Verified (Qwen reports 67.0% with an agentic harness) are the numbers to watch now.
The catch is the one you already guessed. At 480B total parameters, even the standard Q4_K_M weights are roughly 270GB. That means an 8×A100 node, a pair of 141GB H200s, or a 512GB M3 Ultra Mac Studio. The Unsloth dynamic Q2_K_XL quant compresses the footprint to around 150GB with surprisingly small quality loss on code — usable on a 4×48GB configuration — but this is not a model for a single consumer card, and no amount of quantization changes that. Our verdict: if you run a coding agent as a business function and can justify server-class memory, this is the open-weight model to standardize on. Everyone else should read the next two sections.
GLM-5.2 Air: The Single-Card Sweet Spot
Z.ai's GLM-5.2 Air is the release we expect most of this audience to actually deploy. It's a 106B-parameter MoE with only 12B active per token, which is the architecture that makes local inference tolerable: you pay the memory cost of a large model but the compute cost of a small one. At Q4_K_M it occupies about 62GB, which fits a single RTX 6000 Ada (48GB) if you drop to Q3_K_M, or comfortably on a 2×24GB pairing or a 64GB+ unified-memory Mac.
On general reasoning it is the standout mid-tier model of the week: 85.1% MMLU-Redux, 72% on GPQA Diamond, and — the number that matters for daily use — a measured 48 tokens/second on a single 48GB card at Q4, which is well past the threshold where a model feels interactive rather than sluggish. It also inherits the strong tool-calling and agentic behavior the GLM line has been building since 4.5. If you have one prosumer card and want one model that handles chat, RAG, and light coding without swapping weights, GLM-5.2 Air is our pick of the week. Cross-check the throughput math for your own card on the cost calculator before you commit disk space.
LFM2.5 Thinking: Long Context on a 24GB Card
Liquid AI's LFM2.5 Thinking is the quiet winner for readers on mainstream hardware. It's an 8B dense model with an explicit reasoning mode and — the headline feature — a validated 256K-token context window that holds up on retrieval tests, not just on paper. At Q5_K_M it needs roughly 7GB for weights, leaving an RTX 3060 12GB enough headroom for a real long-context session and a 24GB card enough to run it at Q8 with room for a 128K working window.
Benchmarks for an 8B model are never going to threaten the MoE giants, and they don't: expect competent-but-not-brilliant general knowledge. What LFM2.5 Thinking does exceptionally well is long-document summarization, codebase-wide question answering, and RAG pipelines where context length beats raw parameter count. For a self-hosted document assistant on hardware you already own, this is the most useful thing that shipped all week. Pair it with GLM-5.2 Air and you cover the majority of local workloads across two downloads.
Kimi K2.7 Code and MiniMax M2.7: The High-End MoE Race
Two more frontier-scale MoEs rounded out the week. Moonshot's Kimi K2.7 Code is a 1T-parameter model with 32B active, tuned specifically for agentic coding; MiniMax M2.7 is a 480B MoE positioned as a general-purpose flagship. Both are genuinely strong — Kimi K2.7 Code trades blows with Qwen3-Coder 480B on agentic SWE tasks — but neither changes the practical calculus for a single machine. Even aggressive quants leave Kimi K2.7 above 300GB and M2.7 around 260GB.
Our read: unless you are already running server-class memory and specifically want a second opinion alongside Qwen3-Coder, these are models to benchmark, not to self-host at home. We track their scores on the benchmarks hub as third-party numbers land, and you can pull the same figures programmatically — every score, quant size and VRAM estimate on this site is available through the BestLLMfor public API under CC BY 4.0, and via the open-source MCP server if you want the data inside your own agent.
What Runs on Your Hardware
Strip away the launch hype and the week resolves into a simple mapping from VRAM tier to recommendation. This is the table to bookmark.
| VRAM tier | Example cards | Best pick this week | Notes |
|---|---|---|---|
| 12 GB | RTX 3060, RTX 4070 | LFM2.5 Thinking 8B Q5_K_M | 256K context, ~7GB, room to spare |
| 24 GB | RTX 4090, RTX 3090 | LFM2.5 Thinking Q8 or GLM-5.2 Air Q2 | Long-context or a taste of the 106B MoE |
| 48 GB | RTX 6000 Ada, 2×24GB | GLM-5.2 Air Q4_K_M | Best all-rounder of the week |
| 80 GB+ | A100 80GB, H100, 4×48GB | Qwen3-Coder 480B dynamic Q2 | Coding-first, server class |
| 128 GB+ unified | Mac Studio M3 Ultra | Qwen3-Coder 480B Q4_K_M | Slow prompt processing but full quality |
Two practical notes. First, MoE models are far more forgiving of unified memory than dense models of the same footprint, which is why a Mac Studio remains the cheapest path to running the 480B tier at full quality — just budget for slow prefill. Second, always leave 15–20% of VRAM free for the KV cache; the context-window figures above assume you did. For a full model-by-model breakdown across quants, the model catalog lists every variant with measured sizes.
Verdict: What to Download This Week
If you take one thing away: this was a week of two halves, and the frontier-scale headlines are not the models you'll run. Match the pick to the job.
| Use case | Recommended model | Why |
|---|---|---|
| Coding, server-class hardware | Qwen3-Coder 480B | Top open-weight Aider polyglot (71.4%) and SWE-bench score |
| Coding, single prosumer card | GLM-5.2 Air Q4_K_M | Strong code plus reasoning in ~62GB |
| General reasoning / daily driver | GLM-5.2 Air | 85% MMLU-Redux at interactive speed |
| Long documents / RAG | LFM2.5 Thinking | Validated 256K context on cheap hardware |
| 12GB budget build | LFM2.5 Thinking 8B Q5 | Most capable model that truly fits |
For the overwhelming majority of readers the answer is a two-model stack: GLM-5.2 Air for reasoning and code, LFM2.5 Thinking for long-context retrieval. That combination covers real workloads on hardware between 24GB and 48GB, and neither download will be obsolete by next week's recap. Keep an eye on the guides hub for our follow-up head-to-head once independent SWE-bench numbers settle.
Frequently Asked Questions
Can I run Qwen3-Coder 480B on a single RTX 4090?
No. Even the aggressive Unsloth dynamic Q2 quant is around 150GB, far beyond a 24GB card. The smallest realistic single-device host is a 128GB+ unified-memory Mac Studio, or a multi-GPU server. On a 4090, run GLM-5.2 Air at a low quant or LFM2.5 Thinking instead.
Which week-1 June 2026 model is best for 24GB of VRAM?
LFM2.5 Thinking at Q8, or GLM-5.2 Air at Q2/Q3 if you want to sample the larger MoE. For a daily driver with the best quality-to-fit ratio, LFM2.5 Thinking is the safer pick because it keeps a large usable context window in that memory budget.
Are these models really available on Ollama already?
Yes. All five reached Ollama and HuggingFace within 72 hours of release. Day-one GGUF and Ollama support has become standard for major open-weight launches in 2026, though third-party quants (Unsloth, bartowski) sometimes trail the official upload by a day.
Is GLM-5.2 Air good enough to replace a closed API for coding?
For many everyday coding tasks, yes — it handles refactors, test generation and tool-calling well. For large agentic sessions on complex repositories, Qwen3-Coder 480B still leads by a clear margin on SWE-bench Verified, so heavy users may want the bigger model if they can host it.
How do I pull these benchmark numbers into my own tooling?
Every score, quant size and VRAM estimate on BestLLMfor is exposed through our public API under CC BY 4.0, and through the open-source MCP server so you can query it directly from an agent. See the methodology pages for how each figure is measured.
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.