Three open-weight models against Opus
Can an open-weight model compete with Opus? Under what deployment conditions, and at what cost? I put three open-weight models through the bench, and I will try to answer.
I tested GLM 5.2, MiniMax M3, Kimi K2.7 Code. Same protocol, same evaluator, scored numbers. The result cuts against the dominant intuition: on code and analytics, local does not degrade. Sometimes it improves.
The setup
Opus scores 436 out of 460 on our coding benchmark (94.8%). That is the bar. Nine tests, from a Python CLI to a SwiftUI app, from debugging to refactoring, scored at execution where possible.
Two open-weight models clear that bar or sit right on it. A third tells a more interesting story.
MiniMax M3: free sovereignty
447.5 out of 460. 97.3%. MiniMax M3 in Q6 quantization does not compete with Opus, it beats it by 11 points. Locally. No asterisk.
This is the simple case. If your workload looks like the coding benchmark, you take MiniMax, you run it on your infrastructure, and you get better than Opus without sending a single line of code to a third-party provider. The price of independence here is zero. You give up nothing on quality.
Kimi K2.7 Code: parity at 4-bit
436.5 out of 460. 94.9%. That is 0.1 point above Opus. Statistical parity.
The detail that matters: Kimi hits this score at 4-bit, at 17.8 tokens per second on a single Mac. Four panel records along the way, including a microservices architecture that beats both MiniMax and Opus (59/60), a perfect data pipeline, and a Tkinter Mandelbrot at 50/50 that breaks the previous record.
A model compressed to 4-bit, on a single machine, matching a frontier model served by API. Sovereignty here is not just free, it is compact. You do not need a cluster to get it.
The only friction point is operational, not qualitative: Kimi is a reasoning model, its thinking blocks consume token budget and need to be stripped before diff parsing in a client like Aider. An integration precaution, not a competence flaw.
GLM 5.2: the reversal
Here is the model that breaks the intuition.
GLM 5.2 served in the cloud scores 410 out of 460 on coding (89.1%). A notch below Opus. You could stop there and conclude GLM is the weak link of the three. That would miss the point entirely.
Because GLM 5.2 also runs locally, in Q8, on an M3 Ultra. And when you compare the same task between the cloud version and the local version, local wins on six tests out of seven.
| Test | GLM local Q8 | GLM Cloud | Gap |
|---|---|---|---|
| GDPR | 45.5 | 43 | local +2.5 |
| Python CLI | 49 | 43 | local +6 |
| Mandelbrot | 49.5 | 46 | local +3.5 |
| GDPR advanced | 45 | 43 | local +2 |
| Logic | 47 | 46 | local +1 |
| Structural calculation | 50 | 49 | local +1 |
| Long-form fiction | 452.5 | 480 | cloud +27.5 |
On the Python CLI, local takes a six-point lead over cloud. On structural calculation, local lands a perfect 50, above cloud. The only domain where cloud takes back the lead is long fiction, where the gap widens to 27.5 points.
The pattern is clear: where cloud excels, local gives way. Where local excels, cloud gives way. These are not two versions of the same tool with one degraded. They are two complementary tools.
At what price do you win your independence
Let us take the three opening questions back, with the numbers in hand.
At what price? Often zero. Sometimes negative. MiniMax beats Opus locally. GLM local beats GLM cloud on six analytical tasks out of seven. The idea that local is by nature a degraded compromise does not survive the data.
What do you give up? Two specific things, not analytical quality. First, speed: 9 to 18 tokens per second locally against API inference. Second, long-form creative work, the only axis where cloud keeps a measurable and clear advantage. If your job is writing five-thousand-word fiction, cloud stays ahead. If your job is code, GDPR, deterministic reasoning, calculation, local is at level or above.
Does a company that chooses sovereignty lose competitiveness? On the operational core, no. That is the most solid result of this battery. The work that makes up the majority of enterprise loads, production code, regulatory analysis, structured processing, does not suffer from going local. In GLM’s case, it benefits.
What this changes
The cloud-versus-local tradeoff has long been framed as quality against control. You kept your data at home, but you accepted a slightly worse model. These three benchmarks dismantle that frame.
Local quantization is not a mechanical loss of quality. Q8 sometimes beats cloud. Q6 is enough for production-ready code. A 4-bit matches a frontier model. The determining factor is not cloud or local, it is the fit between the model, the quant, and the task. It is a routing problem, not a renunciation.
Technical sovereignty long carried a price tag posted in lost quality. On the numbers of June 2026, that price has become negotiable, and sometimes it reverses.
Sophie, The Monocle Bear