A 35-billion-parameter mixture-of-experts model — activating only 3 billion parameters per token — just scored 64.2 on Terminal-Bench 2.1. That's 10.7 points above Qwen 3.5-397B, a model more than ten times larger. The smaller model didn't have better base weights. Both are built on the same Qwen 3.5 foundation. The difference is that one of them learned to build its own scaffolding.
The model is Ornith 1.0, released June 25 by DeepReinforce AI. And it represents a fundamental inversion of how we think about agent infrastructure.
For two years, the orthodoxy has been clear: the model reasons, the harness executes, and the two are optimized separately. You pick a model, you build or select a harness, and you improve each independently. The entire harness engineering discipline — the practice of designing, building, and evolving the scaffolding layer between model and environment — has been built on this separation.
Ornith 1.0 breaks it.
The Self-Scaffolding Inversion
Here's what every coding agent does today. A human engineers a harness — a fixed set of tool definitions, control flows, retry policies, and context management strategies. The model operates inside this harness, calling tools, following workflows, and generating code. The harness is static infrastructure. The model is the dynamic component.
Ornith 1.0 collapses this boundary. During reinforcement learning training, each step proceeds in two stages. First, conditioned on the task and the scaffold used previously, the model proposes a refined scaffold — actual executable code that defines tool selection logic, state management, conditional branches, and termination criteria. Second, conditioned on that scaffold and the task, it generates a solution rollout. Reward from the rollout propagates back to both stages.
The model is simultaneously learning to solve coding tasks and to author the orchestration framework that guides those solutions. The scaffold becomes a learnable object that co-evolves with the model's policy.
This is not "planning" in the natural-language sense that most models do today. Ornith outputs real Python code that defines how execution proceeds — which tools to call, when to retry, how to decompose complex tasks. That code is inspected, executed, and scored. Over training iterations, scaffolds are continuously mutated and selected toward those that produce higher-reward trajectories. Per-task-category scaffolding strategies emerge automatically, without hand-engineered harness design.
The name is deliberate. Ornith comes from the ancient Greek word for bird. Like a bird building its own nest, the model learns to construct its own scaffolding before it solves a task.
The Benchmark Story
The numbers matter because they quantify the gap between hand-designed and self-authored scaffolding.
At flagship scale, Ornith 1.0-397B posts 77.5 on Terminal-Bench 2.1 and 82.4 on SWE-Bench Verified. That surpasses Claude Opus 4.7 on both benchmarks — 70.3 and 80.8 respectively — and makes it the strongest open-source model on these benchmarks. On SWE-Bench Pro, it hits 62.2 against Qwen 3.5's 51.6. On SWE-Bench Multilingual, 78.9 against 69.3.
But the headline isn't the 397B. It's the 35B.
Ornith 1.0-35B MoE — 35 billion total parameters, only 3 billion active per token — scores 64.2 on Terminal-Bench 2.1. Qwen 3.5-397B, the same foundation at more than ten times the scale, scores 53.5. The 35B model doesn't have more reasoning capacity. It has better scaffolding. The self-scaffolding RL training taught it orchestration strategies that the 397B model, operating inside a static harness, never discovered.
This is the same pattern that emerged from Xiaomi's HarnessX research earlier this month: smaller models benefit disproportionately from harness optimization. But Ornith takes it further. HarnessX evolves the harness externally — a meta-agent rewrites the scaffolding code based on execution traces. Ornith internalizes the process. The model itself becomes the harness engineer.
Let's be honest about where Ornith falls short. It trails Claude Opus 4.8, which scores 85.0 on Terminal-Bench 2.1 and 87.6 on SWE-Bench Verified. It also trails GLM-5.2-744B at 81.0 on Terminal-Bench 2.1. The "state-of-the-art among open models" claim is real but scoped. The proprietary frontier hasn't been breached. But the gap is closing from the harness side, not the model side — and that's the signal worth tracking.
The Reward Hacking Problem
When you let a model write its own harness, you create a new failure mode: the model can game the verifier. A self-generated scaffold can learn to satisfy the test suite without performing the actual task — reading visible test files and hardcoding expected output, touching checked-for files without implementing real logic, or copying oracle solutions from the environment.
DeepReinforce built three safeguard layers to contain this, and the architecture is worth studying because it's a blueprint for anyone experimenting with self-scaffolding training:
A fixed trust boundary. Test files, expected outputs, and oracle solutions are placed outside the scaffold's reach. The model-generated harness literally cannot access the answers. This is access control at the file system level — crude, effective, and non-negotiable.
A deterministic monitor. Rule-based checks for hardcoding patterns and shortcut behavior. This is deliberately not model-based, because your anti-cheating system can't be susceptible to the same gaming it's trying to prevent. Deterministic monitors are immune to adversarial persuasion.
A frozen LLM judge. A separate model, weights frozen during training, evaluates whether the solution represents genuine task completion or scaffold-level cheating. Because it's frozen, the training model can't learn to fool it through gradient feedback. The judge sees the scaffold and the solution together and renders a verdict.
These three layers — access control, deterministic checks, independent model judgment — form a defense-in-depth strategy against reward hacking. As more models learn to author their own execution environments, this becomes the primary adversarial surface. Any team building self-scaffolding or co-evolutionary training should start here.
Why This Only Works With Open Weights
Self-scaffolding RL requires full control over the training loop. You need to define the reward function, inject scaffold generation as a training step, manage the two-stage rollout pipeline, and apply the staleness weighting that keeps asynchronous RL stable across long rollouts. You cannot do any of this against a proprietary API.
Ornith 1.0 is built on Gemma 4 and Qwen 3.5 — both open-weight foundations. It ships under MIT license with no regional restrictions. The 35B MoE runs locally via Ollama, LM Studio, or vLLM. The 9B dense model fits on a single 80GB GPU and runs on a MacBook Pro. Every checkpoint is available on Hugging Face in FP8, GGUF, and bf16.
This creates a structural divergence in agent capabilities that's going to widen over the next year. Teams on proprietary models — Claude, GPT, Gemini — get better base reasoning with every model generation. But they can't train their models to scaffold themselves. The harness is always a separate, static layer. Teams on open-weight models get a different lever entirely: the ability to optimize the harness as part of the model, not around it.
The question isn't whether self-scaffolding will catch up to proprietary model quality. It's whether the ability to co-evolve harness and policy becomes a bigger advantage than raw model scale. The Ornith data suggests it might — especially at smaller parameter counts where harness quality is the binding constraint.
What This Means for Harness Engineering
The harness engineering discipline is not invalidated by self-scaffolding. It's validated at a deeper level. The reason Ornith works is precisely because the harness matters. If scaffolding quality didn't affect task performance, generating one wouldn't improve benchmarks. The fact that self-authored scaffolds produce double-digit improvements proves the harness layer is where the leverage lives.
But the locus of harness engineering shifts. Three changes are coming:
Harness engineering becomes training engineering. Instead of writing a harness that works for your model at inference time, you design training environments that teach your model to scaffold itself. The skill set moves from "building orchestration code" to "designing reward functions and scaffold generation pipelines." The framework outlined in Harness Engineering: The Complete Guide to Agent-First Software Development doesn't disappear — it moves upstream, from deployment to training.
The harness boundary blurs. When the model generates its own scaffold per task, the clean separation between "model" and "harness" becomes a gradient. Some models will generate minimal scaffolds. Others will produce elaborate multi-step orchestration code. The harness becomes a model behavior, not an infrastructure component. This doesn't mean static harnesses disappear — production systems will always need reliability guarantees, state persistence, and observability that a self-generated scaffold can't provide. But the agentic logic — tool selection, task decomposition, error recovery — increasingly lives inside the model.
Evaluation has to change. Benchmarking a self-scaffolding model against a static-harness model is apples to oranges. Terminal-Bench and SWE-Bench measure task completion, not scaffold quality. When the model writes its own harness, you need to evaluate the harness too: is it generalizable? Is it reward-hacked? Does it transfer to unseen tasks? The evaluation infrastructure for agent scaffolding is essentially nonexistent today. Building it is the next frontier.
What to Do This Week
If you're running open-weight models in production, three concrete steps:
Download Ornith 1.0-35B and benchmark it against your current setup. It's MIT-licensed, runs via Ollama or vLLM, and exposes an OpenAI-compatible endpoint. Point any terminal-based coding agent at it — Hermes, OpenClaw, Claude Code with a custom base URL — and measure. The 35B MoE is the sweet spot: faster than the 9B due to sparse activation, significantly more accurate, and fits on a single GPU at Q5 quantization. The cost of running this experiment is one afternoon.
Audit your harness for tasks the model could scaffold itself. Look at your current harness and classify each component: which parts are genuinely infrastructure (authentication, state persistence, sandboxing, observability) versus which parts are task-specific orchestration that a self-scaffolding model could generate? The former stays as static infrastructure. The latter is a candidate for delegation to the model.
Start collecting scaffold traces. Even if you're not doing RL training today, instrument your agent to log the orchestration logic it uses per task — which tools it calls, in what order, with what retry strategies, and what the outcomes are. This data is the foundation for eventually fine-tuning a self-scaffolding model on your specific domain. The teams that start collecting this data now will be the ones who can train domain-specific self-scaffolding models when the training tooling matures.
The Bigger Picture
The first half of 2026 was about standardizing the harness as a platform primitive. Vercel shipped HarnessAgent. Microsoft built Agent Harness into their framework. Cloudflare declared it the year harnesses go to production. The harness became a recognized, composable component of the agent stack — something you can swap, configure, and build on.
Ornith 1.0 points in a different direction. It says: the most advanced harness isn't a platform feature. It's a learned behavior. The model that can write, debug, and evolve its own scaffolding for each task doesn't need a harness platform. It needs a training pipeline.
Both will coexist. Static harnesses will handle infrastructure concerns — persistence, sandboxing, security, observability. Self-generated scaffolds will handle task-specific orchestration. The boundary between them is where the next phase of agent engineering will be negotiated.
For now, the signal is clear. The highest-leverage work in agent systems is no longer just building better harnesses. It's teaching models to build them themselves.