Ornith-1.5: Is This Open Model Really Self-Improving?

Ornith AI shipped Ornith-1.5 on August 20, 2026, and it went straight to the top of Hacker News — 165+ points, 58+ comments as of writing. The pitch, in Ornith's own words, is "From Self-Scaffolding to Self-Improvement": a closed training loop where the model doesn't just solve tasks, it invents new tasks to solve, builds the harness to solve them, and turns its own attempts into the next round of training data.

That is a real escalation from June's Ornith-1.0, which used self-scaffolding RL to write its own agent scaffold but still trained on a fixed, human-curated task set. Ornith-1.5 removes that fixed set entirely — and the benchmark tables that follow are, by Ornith's own account, competitive with Claude Opus 4.8. Before taking that at face value, it's worth asking the questions HN's comment section actually asked: is the self-improvement claim mechanically real, does the 397B model's benchmark lead survive outside Ornith's own harness, and does the smaller 35B model hold up when someone runs it themselves?

TL;DR: What People Are Actually Asking

The Self-Improvement Loop, Mechanically

Ornith-1.0's self-scaffolding idea was: let the model write its own agent harness — memory, retry logic, tool orchestration — instead of hand-coding one per benchmark. Ornith-1.5 keeps that and wraps a bigger loop around it. Each training cycle runs three stages, and all three get trained together:

1. Task generation. The model looks at its own solving history and proposes a new task — one that's progressively harder than what it already handles reliably, deliberately targeting its own capability gaps rather than sampling from a fixed human-written problem set.
2. Scaffold generation. For that task, the model builds or refines a task-specific harness: instructions, available tools, a decomposition strategy for breaking the problem down, and an orchestration approach for running it.
3. Solution rollout. The policy model then attempts the task under the scaffold it just built, producing a rollout that gets scored.

The mechanism that makes this a genuine training-time innovation rather than a rebrand of standard RL: reward from the rollout propagates back across all three stages via GRPO. The model isn't just getting better at solving fixed problems — it's simultaneously learning to generate better problems and better scaffolds, because the same gradient signal touches all three. This is what "self-improvement," as Ornith uses the term, actually names — a training-time data flywheel, not a claim that the shipped model edits its own weights after you download it.

The reward formula, in plain terms

A generated task's reward is the product of three signals, each doing a different job:

• Validity — does the task and scaffold together form a well-defined, reliably-evaluable environment? This is a hard gate: an invalid task gets zero reward no matter how hard it looks, which stops the generator from drifting into unscoreable nonsense.
• Frontier difficulty — reward peaks when the model's own empirical success rate, sampled across several rollouts, sits near a target of roughly 0.2 — challenging enough that most attempts fail, but not so hard that there's nothing to learn from the rare success. As the model masters a task and its success rate climbs, that task's reward naturally decays, which pushes the generator toward harder problems over time without anyone hand-tuning a curriculum.
• Novelty — a secondary penalty or bonus based on how different a new task is from a buffer of previously generated and trained-on tasks, discouraging near-duplicate busywork. Kept subordinate to validity and difficulty by design.

The harness itself is separately rewarded on faithfulness to the task spec, whether it actually tracks solution quality, and resistance to being gamed — a direct answer to the reward-hacking problem that self-generated scaffolds invite, since a model that writes its own grading harness has an obvious incentive to write a lenient one.

Benchmark Tables: What Ornith Actually Reports

Ornith's full tables span coding, reasoning, and agentic benchmarks across five model comparisons per scale. Below is the condensed version — the rows that matter for a "should I use this" decision, not the full spreadsheet.

Ornith-1.5-397B (flagship MoE)

Ornith reports these figures as averaged over five independent runs, evaluated through OpenHands for SWE-bench and Harbor/Terminus-2 for the primary Terminal-Bench variant — the same methodology split as Ornith-1.0. They also note explicit anti-reward-hacking controls for SWE-bench: git history stripped from the repo before evaluation, network access disabled during solving. That's a meaningfully more defensive eval setup than a leaderboard number with no methodology footnote — worth crediting even while treating the numbers as self-reported.

Ornith-1.5-35B (MoE, A3B active)

Ornith-1.5-9B (dense, incl. Mobile variant)

Ornith's headline claim here — that the 9B, and especially the quantized Ornith-1.5-9B-Mobile build, "substantially outperforms" larger models like Gemma 4-31B and Qwen3.6-35B — holds on Terminal-Bench 2.1 against Gemma 4-31B, but the 35B MoE model still edges the 9B on SWE-bench Verified in Ornith's own table. Read "substantially outperforms" as size-adjusted, not absolute.

The Part Ornith's Own Post Won't Tell You: Independent Numbers Disagree

This is the most useful part of the release, and it's not in Ornith's blog post. A Hacker News commenter ran their own comparison of Ornith-1.5-35B against Qwen3.8-27B — the dense, locally-runnable model that hit #1 on Hacker News in mid-August — and posted a table that tells a rougher story than Ornith's official numbers:

Two things stand out. First, the gap on DeepSWE is large — 42.2 vs 22.0 — nearly double, on a benchmark that's specifically hard to game since it stresses long-horizon software engineering rather than single-file patches. Second, this is one commenter's informal run, not a peer-reviewed reproduction, and it's comparing a 27B dense model against a 35B MoE model with different active-parameter counts — not an apples-to-apples architecture match. Treat it as a useful data point that contradicts the official table, not as the final word.

This tension — a vendor's own five-run-averaged benchmark suite against one practitioner's single independent run — is exactly the gap explainx.ai's reward-hacking coverage of SWE-bench keeps surfacing: leaderboard numbers and reproduced numbers diverge often enough that "self-reported" should always carry an asterisk, regardless of how careful the reporting methodology looks on paper.

Separately, at least one HN commenter noted the model "reliably claims to be Claude" across several identity-probe tests. That's a known phenomenon across open models whose training data is shaped by Claude-generated text in web corpora or synthetic data pipelines — it's evidence of training data contamination, not evidence that Ornith copied Claude's weights or architecture.

What People Are Asking

"Is the base model actually Qwen3.5 under the hood?" Per HN community research, yes — Ornith-1.5-397B is reportedly derived from Qwen3.5-397B-A17B via post-training, preserving the exact parameter count. This isn't confirmed in Ornith's own materials as of publication, so attribute it to community reverse-engineering rather than an official disclosure. If accurate, it mirrors Ornith-1.0's pattern of post-training existing Qwen and Gemma bases rather than pretraining from scratch — the self-improvement loop here is a post-training technique, not a new foundation model.

"Who's actually behind Ornith?" HN commenters trace the project to Jiwei Li. Ornith-1.0 was attributed to DeepReinforce.AI; whether Ornith AI is the same team under a new name or a related spinoff isn't spelled out in the 1.5 announcement. Treat the founder attribution as community-sourced until Ornith states it directly.

"Does this compress well for edge deployment?" The Ornith-1.5-9B-Mobile variant is the most practically interesting claim in the release — a quantized build Ornith says deploys on iPhone and Android. If real-world response latency and accuracy hold up outside Ornith's own testing, it's a genuinely useful option for teams evaluating local, on-device coding assistants rather than API-bound tools.

"Why does the self-improvement loop not just collapse into reward hacking?" Because validity is a hard gate before difficulty or novelty even get computed, and the harness is scored separately on faithfulness and gaming-resistance — the same three-layer defense-in-depth pattern (trust boundary, deterministic checks, adversarial scoring) that Ornith-1.0 used for its scaffold-writing RL, extended to cover task generation too.

Should You Actually Use It?

Reasonable fit:

• Researchers and teams curious about self-generated RL curricula as an alternative to fixed, hand-curated task sets — the training methodology is worth studying independent of whether the leaderboard numbers hold up.
• Edge and mobile deployments where a quantized 9B model with agentic coding competence beats shipping a much larger model you can't run locally.
• Teams already comfortable evaluating self-reported benchmarks skeptically and willing to run their own reproduction before swapping production models.

Wait and verify first:

• Anyone deciding between Ornith-1.5-35B and Qwen3.8-27B based on Ornith's tables alone — the one independent data point available so far disagrees with Ornith's own numbers, sometimes by a wide margin.
• Production systems that need benchmark numbers reproduced on your own repos and CI before a model swap, not vendor tables.
• Anyone relying on the founder/company attribution as settled fact — it's HN-sourced, not confirmed.

Browse more open-weight coverage in the explainx.ai LLM directory and agent tooling in the MCP server registry.

Related Reading

• Ornith-1.0: Self-Scaffolding Open Models for Agentic Coding
• Qwen3.8-27B Is Live — The Local Model Hacker News Put at #1
• Weco AIDE²: Recursive Self-Improvement, Level 1
• Cursor Reward Hacking and SWE-Bench Eval Contamination
• Top 10 Open-Weight Models You Can Run on a Laptop
• Choosing Between Open-Weight and Closed AI Models
• GRPO — AI Dictionary
• Self-Scaffolding RL — AI Dictionary

Sources: Ornith AI's Ornith-1.5 announcement (ornith.ai, August 20, 2026), the Hugging Face Ornith-1.5 collection, and the Hacker News discussion thread (165+ points, 58+ comments as of writing). Benchmark figures are Ornith's self-reported numbers unless explicitly marked as community-sourced; independent reproduction of the 397B claims was not yet available at publication. Model sizes, licensing terms, and comparative benchmarks are accurate as of the publication date and may change as the community reproduces results.