Qwen's agentic coding is the real story in open models

Ornith-1.0-35B scores 64.2 on Terminal-Bench 2.1. The Qwen 3.5-35B base it was trained from scores 41.4. The Qwen 3.5-397B base, more than ten times the size, scores 53.5.

That gap is the most interesting thing I’ve read about open models this month, and it isn’t about which model tops a leaderboard. It’s about what happens when you train a decent model to hold a long piece of work together.

Most conversations about open weights still circle back to “which one wins the latest benchmark”. I understand why. It’s an easy number to compare. But the work that eats real tokens in an agent system looks different: planning over many steps, calling tools and reading what comes back, checking results, fixing mistakes, and staying coherent across hundreds of turns. On that kind of work, Qwen has quietly pulled ahead among open models.

Where the gap shows up

On agent-centric coding benchmarks, recent Qwen releases sit at or near the top of the open-weight field. The advantage isn’t so much in single-shot code generation. It shows up on tasks that need sustained context, tool calls and several rounds of refinement.

Longer context windows help. So does training aimed at following instructions and respecting tool schemas. Together they produce models that hold together when an interaction stretches past a few exchanges. Plenty of models that look sharp on a single prompt fall apart once they have to keep track of state across tool calls and half-finished results, and that’s usually where an agent run goes wrong.

What Ornith adds on top

Ornith-1.0 post-trains Qwen 3.5 (and Gemma 4) bases for agentic coding, and its trick is teaching the model to write its own scaffolds.

Instead of working inside a fixed harness that a human designed, the model learns to propose a scaffold suited to the task, produce a solution under it, and then receive a reward that updates both the scaffold proposer and the solution policy.

The authors put real effort into stopping the model gaming its reward. There’s a fixed outer trust boundary, a deterministic monitor that zeroes out invalid trajectories, and a frozen LLM judge with a final veto. Long rollouts are handled with pipeline RL and staleness weighting.

The lift is large at a practical size. Besides the Terminal-Bench numbers above, Ornith-1.0-35B improves on SWE-Bench Verified too, though more modestly (75.6 against 70.0). The 9B variant is already competitive with much larger dense models on these tasks.

None of that came from more pre-training data or more parameters. It came from the model learning better scaffolding.

Why scaffolding beats scale

I’d take a model that reliably drives a long piece of software work over one that occasionally writes something clever and then loses the thread on the third tool response. Every time.

You can see the difference in rework and token spend. An agent that needs constant steering, or keeps restarting, burns budget and leaves a messy trail behind it that nobody wants to review. One that finishes the job with fewer interventions is cheaper, and what it leaves behind is easier to check.

Qwen’s edge, and the extra lift from recipes like Ornith, comes from paying attention to unglamorous things. Calling tools accurately. Keeping context intact across sub-tasks. Surfacing reasoning in a form later steps can use.

On fine-tuning as a business

A lot of companies have raised money on running models locally for regulated industries. Many of them take an open-weight base, add a niche or proprietary dataset, and do fairly standard supervised fine-tuning or preference optimisation.

That’s a legitimate thing to do, and specialised data does have value. My worry for anyone whose whole offer is curated data plus GPU time is that the bases keep getting stronger and cheaper every quarter. Ornith is a good illustration of what’s harder to copy: joint optimisation of scaffold and solution, custom RL pipelines, new training objectives. The open-weight labs, DeepSeek, Qwen and MiniMax among them, keep shipping that kind of advance too: better sparse attention, more efficient MoE routing, steadier long context, more capability per training token. Those compound. A few hundred GPUs on a specialised dataset tend not to.

Running it on your own ground

For teams that have to keep data and processing inside their own boundary, strong agentic performance in open weights changes the maths.

Until recently the choice was awkward. Use a closed hosted model and accept the data and cost exposure, or run an open model locally and accept that anything complex needed a person watching it closely. Open models that hold up over long, multi-step work, plus post-training that specialises them for agents, make the local option realistic for jobs that used to need hosted access. Efficiency gains in the same model families also cut the hardware you need to serve them at a useful rate.

GLM 5.2 belongs in this conversation too. It’s drawn a lot of praise from developers for how well its long context holds up over long agentic coding runs, and for coding results close to the closed frontier models at much lower cost. Developers keep mentioning how hard it hunts for edge cases, and how useful it is as a second opinion in multi-model loops.

Put DeepSeek V4, Qwen and GLM 5.2 side by side and the open models now sit at or just behind the closed frontier on long-horizon agentic work, at a fraction of the price. The gap is narrowest exactly where production agents spend their time.

The model is the easy part now

A capable model still needs a lot around it. Something has to say which rules the agent works under and stop it before it goes past its scope or its budget. Something has to record who changed what, and why, in a way an auditor can follow later. And once the code exists, somebody has to deploy it, isolate it, secure it and keep it running.

That’s the part I spend my time on. Kizuna is where agents build software under the rules you set; Voxeltron is where what they build runs. The better the open models get, the clearer it becomes that writing the code was never going to be the bottleneck for long.

So if you’re evaluating open stacks, test the headline benchmarks, and then test mission-length work: ten tool calls, a couple of approval gates, state that has to survive the whole run. The model that wins an isolated reasoning test can still lose there. For regulated teams, that second test is the one that decides whether the thing gets to run at all.