Kimi K3, Qwen 3.8, and a Week That Reset the Open-Weight Frontier

Canonical version: Kimi K3, Qwen 3.8, and a Week That Reset the Open-Weight Frontier.

July 2026 was a LOT. Two open-weight models at frontier scale announced within three days of each other, a 27B model that runs on a phone, and a pile of tooling news that will affect your daily work more than either of them.

Let me walk you through what actually matters.

The big one: Kimi K3

Moonshot AI released Kimi K3 on 16 July, with weights on Hugging Face by the 27th. 2.8 trillion parameters, 16 of 896 experts active per token, 1M context, natively multimodal.

The number that made people sit up is not the parameter count. It's this: Fable 5 and GPT-5.6 Sol are the only models Moonshot claims to trail. Fireworks published an analysis titled "Kimi K3 is competitive with Fable", and practitioners keep reporting that they run K3 alongside Claude on normal coding work and cannot tell them apart.

The architecture is where it gets genuinely interesting. K3 is not K2.6 with more parameters. Nearly every conventional component was swapped for a cheaper one: Stable LatentMoE, multi-head latent attention, Kimi Delta Attention, and no positional embeddings at all. Everyone else hedges by keeping RoPE in the local layers. Moonshot dropped it entirely, because the recurrent gating in KDA encodes position implicitly.

Why does that matter to you? Because it undercuts the story that Chinese open models are just distillations of Western ones. That story got a lot harder to defend this month.

The catch: pricing is $3 / $15 per million tokens, which is 1:1 with Anthropic's Sonnet series. For a Chinese open-weight model, that is startling, and it is the most argued-about number in every thread. GLM 5.2 is under a third of the price.

Qwen 3.8, three days later

Alibaba announced Qwen 3.8 on 19 July: 2.4 trillion parameters, multimodal, claimed to be "second only to Fable 5".

Here's the thing. What actually shipped is qwen3.8-max-preview, available through Alibaba's Token Plan and its Qoder coding platforms at 10% of standard pricing. As I write this, thirteen days later, there are still no weights, no model card, no license, and not a single published benchmark. Nothing from the Qwen org on Hugging Face since June. The active parameter count (the number that actually determines what a sparse MoE costs to run) is undisclosed.

If you see coverage saying the weights landed on 27 July, that's the Kimi K3 date being copied across. Alibaba said "soon" and named no date.

The timing tells you more than the announcement does. Two days after K3. But here's the part that makes the promise interesting rather than merely defensive: Alibaba kept its flagship Max tier closed for two straight generations. 3.6-Max and 3.7-Max were API-only. Saying it will open the biggest model it has ever trained is a genuine reversal, and it would cost them something.

So far it's a sentence, not a repository. Worth watching, not worth planning around.

The broader strategy shift is real either way: Chinese labs built their reputation on small, fast, cheap, good enough. These are the opposite bet.

Bonsai 27B runs on your phone

This is my favourite release of the month, and it got the least attention relative to how big a deal it is.

Bonsai 27B from PrismML is an extremely low-bit compression of Qwen3.6-27B, Apache 2.0. Two variants:

• Ternary at 1.71 effective bits per weight: 5.9 GB, retains 95% of the full-precision benchmarks
• 1-bit at 1.125 bits: 3.9 GB, retains 90%

For reference, the full-precision model is about 54 GB, and a normal 4-bit build is 18 GB.

A 27B-class model, with reasoning and a 262K context and multimodal input, fitting inside an iPhone. That's not an increment, that's a step change in what "local" means.

One caveat that matters if you're building agents: tool calling degrades most (74.0 ternary, 66.0 for 1-bit, against an 80.0 baseline). Fine for chat and reasoning. Test it hard before you put it in a loop.

Gemini 3.6 Flash: cheap, fast, and quietly the real story

Gemini 3.6 Flash landed on 21 July at $1.50 / $7.50 per million tokens, 17% more token-efficient than 3.5 Flash, and better at coding and tool use. Alongside it: 3.5 Flash-Lite at $0.30 / $2.50, and a security specialist called Flash Cyber.

Google spent its earnings call being asked by four banks in a row what it plans to do about not having a state-of-the-art model. The answer each time: everyone uses Flash anyway.

Honestly? They're half right. Most agentic spend is Flash-tier spend, and Google's cloud revenue was up 82% year over year. But their announcement benchmarks these models only against previous Gemini versions. No comparison to Claude, to GPT, to Kimi, to GLM. For a release whose entire argument is cost-effectiveness, that absence is the loudest thing in the document.

Cursor published the numbers on agent swarms

This one is required reading if you run agents at scale. Cursor Agent Swarms documents implementing SQLite from scratch with different model combinations, and publishes the bill:

GPT-5.5 workers alone cost $9,373. Opus planning plus cheap workers cost $411 for the same layer. The worker tier is where the money goes, and it's the tier where model choice matters least.

But the cost table isn't even the best part. Compare their old orchestration to the new one, same model, same task:

• Commits: 68,000 → 1,000
• Merge conflicts: 70,000+ → under 1,000
• Final engine code: 64,305 lines → 9,908 lines

Six times less code for the same working result. The old swarm wasn't slower. It was generating waste at industrial scale and calling it progress. Every fix they applied is topological (impartial reconciler agents, decorrelated reviewers, shared design docs), which is exactly what graph engineering predicts.

DSLs are how you make LLMs reliable

Unmesh Joshi published a piece on Martin Fowler's site that I think is one of the most useful things written this month: DSLs Make LLM Output Reliable.

The argument in short: a general-purpose language offers a hundred valid ways to express one intent, and a DSL strips the variation away. Every choice the language already made is a choice the model can no longer make badly. Add a validator (a parser, a schema, a compiler) and your agent can self-correct without you.

The part I'd add: a DSL also works as the handoff contract between agent steps. Pipe natural language through five model calls and the fifth receives something quite different from what its prompt expects. Make the DSL the contract at each boundary and the drift stops compounding.

I also wrote up the concept itself in Domain Specific Languages (DSLs), with book references, because DSLs are worth understanding properly and most people only ever meet them as YAML.

The tooling round-up

Several smaller things worth knowing:

• JetBrains Context: a semantic index of your repositories that agents query by concept instead of grepping around. Claims up to 68% fewer agent turns and 48% lower cost. Works with Claude Code and OpenAI Codex, not just Junie, which tells you JetBrains reads the index as the durable asset and the agent as swappable. They're right about that
• GitHub Copilot Vision went generally available on 1 July. Attach images and PDFs to a Copilot chat, on every plan including Free. Not novel, but it removes a translation step you were paying on every single interaction
• LM Studio Bionic: an agent app built specifically for open models. The skepticism is fair (every open harness already talks to LM Studio) but the question underneath is real: can a harness tuned for small local models close enough of the gap to make local agents useful daily?
• NotebookLM is now Gemini Notebook. Same product, folded into the Gemini brand
• FFASR Leaderboard: the first open far-field speech recognition benchmark. The finding is blunt: word error rate in a real room at low signal-to-noise is several times higher than in a clean booth. Every ASR model has been optimized for the condition we could measure, and nobody deploys in an anechoic chamber
• Codex Micro: OpenAI made a $230 macro pad with a dial for reasoning effort and RGB keys showing live agent status. It's a rebranded Work Louder pad and you should buy a Stream Deck instead. But the needs it targets are real: see what every agent is doing, approve or reject fast, adjust how hard the model thinks

What I take away from all this

Three things.

One: the open-weight frontier is real now, and it is expensive. K3 at Sonnet pricing is the end of "open means cheap". You're paying for capability, not for weights.

Two: the money is in the worker tier, not the planner tier. Cursor's numbers make this undeniable. If you run agents and haven't separated planning from execution, that's the highest-return change available to you this week. Simon Willison's Fable 5 follow-up takes it one step further: don't just delegate the work, delegate the decision about which model does it.

Three: local keeps eating upward. Bonsai puts a 27B model in your pocket. Every quarter, more real tasks cross the line from "needs a frontier model" to "runs fine on my hardware". Treat the local tier as a first-class option, not a fallback.

Related

• Kimi K3
• Qwen 3.8
• Gemini 3.6 Flash
• Bonsai 27B
• Cursor Agent Swarms
• Codex Micro
• LM Studio Bionic
• JetBrains Context
• GitHub Copilot Vision
• FFASR Leaderboard
• NotebookLM
• DSLs Make LLM Output Reliable
• Domain Specific Languages (DSLs)
• Graph Engineering
• Moonshot AI
• Qwen
• Claude Fable 5
• GPT-5.6
• AI Open Weight Models
• Running AI Models Locally
• AI Agent Swarms
• Agentic Engineering
• Simon Willison

About Sébastien

Ready to get to the next level?