The Deep Reinforce team argues that hand-built harnesses (system prompts, tool registries, planning loops) are frozen artifacts of one team's intuitions about agent cognition, and they cap the agent at the harness designer's ceiling. By training the model via RL on its own execution traces to emit its own tool definitions, sub-agent prompts, and verification steps, they claim the ceiling moves with the weights rather than with human engineering effort.
By surfacing the longer-form self-scaffolding writeup to HN, this submitter is amplifying Deep Reinforce's core thesis that the harness is the wrong abstraction. The 75-point score signals that a meaningful slice of the HN audience finds the architectural argument — not just the weights drop — worth engaging with.
The editorial concedes that models writing their own scaffolding is not new — Voyager, Self-Refine, Reflexion, and STaR all explored variants of self-improvement. What makes Ornith notable is that it ships a full agentic coding system end-to-end with weights, training recipe, and writeup as open source, rather than as a single-domain research demo.
By framing the submission as 'self-improving open-source models for agentic coding' and driving it to 225 points, this submitter is highlighting the open-weights + open-recipe aspect as the headline story. The community's strong upvote response suggests interest is driven by the rare combination of agentic-coding ambition and full openness, not by the underlying RL-on-traces idea.
Deep Reinforce, a small Seoul/SF research group, dropped Ornith-1.0 on GitHub this week with weights, training recipe, and a companion writeup at deep-reinforce.com/ornith_1_0.html. The repo hit 225 on Hacker News within hours; the longer-form post pulled another 75. The pitch is two words that don't usually appear together: self-scaffolding.
Most agentic coding systems today — Claude Code, Cursor's agent mode, Aider, OpenAI's Codex CLI — pair a strong base model with a hand-engineered harness: a system prompt, a tool registry, a planning loop, retry logic, file-edit primitives. The harness is where months of human effort live. Swap the model behind any of these and you keep ~80% of the agent's competence, because the scaffolding is doing the heavy lifting.
Ornith-1.0 inverts that. The model is trained, via reinforcement learning on its own execution traces, to *emit* its scaffolding — tool definitions, sub-agent prompts, verification steps — as part of the rollout. The training loop runs the agent end-to-end on real coding tasks (SWE-Bench-style repo edits, plus an internal task set), grades the outcome with unit-test pass/fail and a learned reward model, and updates the policy on whichever scaffolds led to passing builds. There is no human-authored harness in the inner loop.
The technical bet here is specific and worth stating cleanly. Deep Reinforce is arguing that the harness is the wrong abstraction layer for agency — it's a frozen artifact of one team's intuitions about how a model should think, and it caps the agent at the harness designer's ceiling. If the model can learn its own scaffolding from outcomes, the ceiling moves with the weights.
This isn't a new idea. Voyager (2023) had GPT-4 write its own Minecraft skill library. Self-Refine, Reflexion, and STaR all rewarded a model for improving its own reasoning trace. What's different about Ornith is the scope and the openness: it's a full agentic coding stack trained this way, with weights and the RL recipe public. The closest commercial analog is whatever OpenAI is doing inside o3/o4 with tool use during post-training — but that's a black box, and the consensus reading is that it's still operating against a fixed tool surface.
The benchmark numbers in the writeup are credible but not stunning. On SWE-Bench Verified, Ornith-1.0 reports roughly mid-50s resolved rate, behind Claude Sonnet 4.5 + a tuned harness (low 70s) and roughly tied with GPT-5-mini with default Codex scaffolding. The interesting claim isn't the absolute score — it's the delta when you strip the harness: Ornith loses ~3 points without external scaffolding, while Claude and GPT-5 lose 15–25. If that holds up under independent eval, it means the model has internalized something the harness used to provide externally.
HN commenters are split, predictably. The bullish read: this is the right direction, agent harnesses are technical debt waiting to be amortized into weights, and an open-source group beating closed labs to a working self-scaffolding recipe is exactly the kind of asymmetric win that keeps open weights relevant. The bearish read: RL on execution trajectories is the same recipe everyone's been trying since Reflexion, the benchmark gap is still real, and "self-improving" is doing a lot of work in the marketing. Both are right. The interesting question is whether the *training* recipe — not the resulting checkpoint — is the artifact worth copying.
One specific thing worth flagging: the reward model. Deep Reinforce is training on outcome reward (tests pass / tests fail) plus a learned preference model over scaffolding quality. Outcome reward alone is famously sparse on coding tasks — most rollouts fail, gradients are tiny, and you collapse into degenerate scaffolds that game the tests. The preference model is the load-bearing piece, and the repo is light on detail there. If the preference model is itself trained on Claude or GPT-5 outputs — which would be the obvious shortcut — then Ornith is implicitly distilling a closed model's taste for what a good agent looks like, and the "self-improving" framing gets weaker. The training writeup doesn't confirm or deny this.
Don't rip out Claude Code for Ornith-1.0 today. The harness-tuned closed models are still ahead in raw resolve rate, and the gap on real-world repos (which is always wider than benchmark gap) is probably larger than the SWE-Bench numbers suggest.
What is worth doing now: read the training recipe. Even if you never run Ornith, the recipe is a working blueprint for fine-tuning your own coding agent against your own tests — which is the actual moat for any team shipping internal devtools. If you have a private repo with a strong test suite, an RL loop that rewards passing tests on real PRs is genuinely useful, and the field has been short on reproducible recipes for this until now.
The second thing worth doing is auditing your current harness. If a model trained to emit its own scaffolding can come within 15 points of a heavily-tuned closed-model harness, your harness is probably overfit to the model you wrote it against. When you swap models — and you will, every six months — the harness needs to come along for the ride. A model that produces its own scaffolding makes that swap cheaper. A model behind a hand-tuned harness makes it more expensive. That's a procurement consideration, not just a research one.
For the open-source AI tooling crowd specifically: Ornith-1.0's weights are MIT-licensed and the training code is Apache 2.0. That makes it usable as a base for downstream fine-tunes in a way that Llama (custom license) and most distilled DeepSeek variants are not. Expect community forks within weeks, mostly trained against narrower task distributions — frontend, infra-as-code, data engineering — where the scaffolding self-emission has the most room to specialize.
The next six months will tell us whether self-scaffolding is a real research direction or another Reflexion-shaped local maximum. The tells to watch: independent SWE-Bench evals (the LMSYS team usually publishes within a month), forks that report cleanly on harness-stripped performance, and whether OpenAI or Anthropic ship anything that looks like training-time scaffolding emission in their next model card. If the answer to all three is yes, the harness-as-product market — Cursor, Continue, Aider — gets compressed fast. If the answer is no, Ornith is a useful artifact and a fine training recipe, but the hand-tuned harness keeps its margin for another cycle.
This is the first Qwen fine-tune that is not immediately rejected by the local LLM community, and in some cases even being recommended. Based on my limited usage, it is good, gives creative solutions to coding problems. I don't expect 9-35B models to one-click create full apps. Most people who
I've been testing Ornith-1.0 35B (my own FP8-block quant) and I like it. It runs at >200 tok/s w/ vLLM on an RTX PRO 6000 (sm120), I've run >140M cached tokens of agentic coding work on it over the past few days. It seems to about somewhere between Qwen 3.6 35B-A3B and 27B,
From what I personally tested Ornith-1.0 35B is slightly better than Qwen-3.6 35B. My tests are tasks that consist of adding/modify feature in a big C++ codebase. The part that I find interesting is that the model is way faster than Qwen3.6 35B. It seems Ornith produce a smaller chain of though
Can anyone explain what’s the story here? Is this just a re-skinned qwen? Who is deepreinforce-ai and why isn’t this model listed on their website?How does it self-improve, does the model change on disk - or just during a single context run it gets better?
Top 10 dev stories every morning at 8am UTC. AI-curated. Retro terminal HTML email.
Previously: https://news.ycombinator.com/item?id=48709744https://swelljoe.com/post/will-it-mythos/: "Poor performer here, only found the one bug that almost every model found, despite its performance on other benchmarks being excellent for its size. […] I