Most coding models learn to solve problems. Ornith-1.0 was trained to build its own scaffolding first — the harness of tools and structure an agent needs — and then solve the task inside it. That's the unusual idea behind DeepReinforce's open model family, released in June 2026 under a permissive license. It's not an IDE, not a finished coding agent, and not a hosted product — it's a set of open-weight models you can download and run yourself. Here's what Ornith-1.0 actually is, where to get it, how to read its benchmark claims, and what to check before testing it on real work.
Model details and benchmarks below reflect DeepReinforce's published information as of June 2026. Confirm current specifics against the official model cards before relying on them.
Ornith-1.0 in One Paragraph
Ornith-1.0 is an open-source, MIT-licensed family of large language models built by DeepReinforce specifically for agentic coding. Released on June 25, 2026, it spans four parameter sizes — 9B Dense, 31B Dense, 35B MoE, and 397B MoE — all under the MIT license with no regional restrictions. The distinguishing idea is in how it was trained: rather than only learning to produce solutions, Ornith models learn to construct their own scaffolding (the tool structure around a task) as part of the same self-improving process — hence the name, from the Greek word for bird, as in a bird building its own nest. Critically for how you evaluate it, Ornith-1.0 is a model family, not an application: it's weights you run, not a coding tool you open.
Official Sources and Release Surface
DeepReinforce blog, Hugging Face, and Ollama
The authoritative sources for Ornith-1.0 are DeepReinforce's own channels. The weights are published on Hugging Face under the deepreinforce-ai organization, where the model cards document each variant, its serving recipes, and DeepReinforce's benchmark results. DeepReinforce also maintains a public repository with the shared serving setup. For local use, the models are distributed through the usual open-weight runtimes — Ollama (which added Ornith to its library shortly after launch), plus vLLM, LM Studio, and llama.cpp — and the model cards give OpenAI-compatible serving commands for each. When you evaluate Ornith, these first-party sources are what to cite; secondary write-ups may describe older states or add framing the official cards don't.
9B, 31B, 35B, and 397B variants
The family's four sizes target different deployment points. The 9B Dense is the lightweight, edge-deployable member, runnable on a single GPU (and in quantized form on modest hardware). The 35B MoE is positioned as a practical sweet spot — a mixture-of-experts model with only a few billion parameters active per token, so it can be efficient while more capable than the 9B. The 31B Dense and the 397B MoE flagship round out the range, with the 397B positioned by DeepReinforce as its most capable variant. An architectural detail worth knowing: the 9B, 35B, and 397B are post-trained on a Qwen base, while the 31B is post-trained on a Gemma base — Ornith's contribution is the reinforcement-learning and self-scaffolding training layered on those bases, not a from-scratch pretrain. Note that availability varies by variant and runtime — some sizes reached Ollama's library before others — so confirm which checkpoints are currently published before planning around a specific one.
Self-Scaffolding Training, in Plain Terms
The headline of Ornith-1.0 is its training approach, so it's worth explaining plainly. A normal coding model is trained to output a solution. An agent built on such a model relies on a human-designed scaffold around it — the tools, the prompt structure, the loop that lets it act. Ornith's training jointly optimizes both: the model learns to build the scaffold and solve the task in one self-improving reinforcement-learning process, rather than treating the scaffold as fixed and external.
The practical intuition is that a model which learned to construct its own working structure may adapt that structure to the task, rather than depending entirely on whatever harness you wrap it in. Whether that translates into better real-world results for your work is an empirical question — the training idea is genuinely novel, but "novel training method" and "better on my tasks" are different claims, and only testing tells you if the approach pays off in your setup. What the self-scaffolding design does clearly signal is intent: Ornith is built for agentic use (tool-calling, terminal work, multi-step tasks) rather than single-shot code completion, which shapes who it's for and how to evaluate it.
How to Read the Benchmark Claims
SWE-bench, Terminal-Bench, NL2Repo, and ClawEval
DeepReinforce reports Ornith's results on a set of agentic-coding benchmarks: SWE-bench (real GitHub-issue resolution), Terminal-Bench 2.1 (terminal-task completion, evaluated via the Terminus-2 harness per the model cards), NL2Repo (natural-language-to-repository generation), and ClawEval/OpenClaw (agent-harness evaluation). These are the relevant axes for an agentic coding model — they measure tool-use and multi-step task completion, not just code snippet quality — so they're the right benchmarks to look at. The model cards give specific numbers per variant along with the exact evaluation settings (harness, parser, temperature, context window) used to produce them.
Vendor-reported results and harness caveats
Every one of those numbers is DeepReinforce's own reported result, as of the publication date — not an independent third party re-running the models under controlled, identical conditions. That doesn't make them wrong, but it means they're a capability signal from the model's authors, not a neutral verdict, and should be cited that way ("DeepReinforce reports…," with the date). Two caveats matter especially for agentic benchmarks. First, the harness swings results heavily: the same model scores differently under different scaffolds, and DeepReinforce's numbers reflect the harness and settings they chose (documented on the cards) — a different harness on your side can produce different results. Second, comparisons to other models are only as fair as the conditions, so "rivals [frontier model]" claims are directional, not measured guarantees for your work. Read the benchmarks as a reason to test Ornith, not as a substitute for testing it.
Who Should Test Ornith First
Ornith-1.0 is most worth testing for developers and teams who specifically want an open-weight, locally-runnable coding model for agentic work — people who value being able to run the model on their own hardware (for data control, cost at scale, or offline use) and who work with tool-calling agents rather than plain autocomplete. The MIT license and no-regional-restriction release make it broadly usable, and the range of sizes means you can match a variant to your hardware — from a laptop-scale 9B via Ollama to a multi-GPU 397B.
It's a weaker fit if you want a turnkey, hosted coding assistant with no setup — Ornith is weights, not a product, so using it means running it in a runtime and wiring it into an agent yourself. If you're not set up to serve an open model or don't need local control, a hosted service may suit you better. The clearest "test it first" audience is teams already running local open models (the ones with the Qwen-style setup Ornith uses will find it familiar) who want to evaluate a novel agentic-coding option on their own infrastructure.
Limits, Risks, and Verification Notes
The main things to verify follow from what Ornith is. Because it's a fast-moving open release, confirm the current state of each variant (which checkpoints are actually published, on which runtimes) against the official repository rather than assuming the full announced family is available everywhere — some sizes reached some runtimes before others. Because the benchmarks are vendor-reported, treat them as claims to validate on your own tasks, not as settled facts. And because it's an open-weight model you run yourself, the operational responsibility is yours: serving it, resourcing the hardware, and integrating it into an agent harness are your work, and the model's quality in practice depends partly on that harness.
The deeper caveat is the gap between the novel training idea and real-world performance. Self-scaffolding is a genuinely interesting approach, but a model being trained in an interesting way doesn't guarantee it outperforms established models on your code — that requires evaluation. And as with any code-generating model running with tool access, the output needs human review before it's trusted, especially in an agentic setup where the model can take actions. Treat Ornith as a promising open option to evaluate carefully, with the benchmarks as a starting hypothesis and your own testing as the decision.
FAQ
Does the MIT license allow commercial coding workflows?
The MIT license is a permissive open-source license that generally allows commercial use, modification, and distribution with minimal conditions (chiefly retaining the copyright and license notice), which is why MIT-licensed models are widely usable in commercial settings. That said, for any specific commercial deployment you should read the actual license text as published with the model, and confirm there are no additional terms or use restrictions in the model card beyond the MIT grant, since a release can pair a base license with supplementary conditions. DeepReinforce released Ornith under MIT with no regional restrictions, which is about as permissive as open releases get — but verifying the exact license text and any accompanying terms against the official model card is the right step before building a commercial workflow on it, rather than relying on a general description of MIT.
What should teams verify before private repo tests?
Before pointing Ornith at a private repository, verify the operational and boundary questions that come with running an open model in an agent. Confirm where the model runs and that your setup keeps private code within your controlled environment (a locally-served open model can stay entirely on your infrastructure, which is a data-control advantage, but only if you've configured it that way). Confirm what the agent harness you're wiring Ornith into is permitted to do — read-only versus write access, which tools it can call — and start read-only or on a sandbox copy before granting write access to a real repo. Verify the model and harness behave sensibly on a bounded, representative task before scaling to important code. The point is to earn trust incrementally and keep private code within boundaries you've confirmed, rather than connecting a fresh model to a sensitive repo on first run.
How should benchmark claims be cited after release?
Cite them as DeepReinforce's reported results, with the date and, where it matters, the evaluation conditions. Because the numbers are vendor-reported rather than independently verified, accurate attribution is "DeepReinforce reports [result] on [benchmark] as of [date], using [harness/settings]" rather than stating the figure as an established fact. This matters because agentic benchmark scores depend heavily on the harness and settings used, which the model cards document — so a citation that omits those conditions can mislead. When comparing Ornith to other models, note whether the comparison was run under matched conditions or is drawing from separately-reported numbers, since cross-model claims are only as sound as the conditions behind them. The honest citation frames the benchmarks as the authors' reported signal, verifiable against the model cards, not as a neutral third-party verdict.
What logs help compare Ornith against existing coding models?
To compare Ornith fairly against models you already use, capture the things that reveal real performance rather than just final output. Log the full agent trace — the tool calls the model made, its reasoning steps where available, and the sequence of actions — so you can see how it approached a task, not just whether it finished. Record the outcome against a real acceptance check (did your tests pass?), the number of correction cycles it needed, and any failures and how it recovered. Keep the harness and task identical across the models you're comparing, so differences are attributable to the model rather than the setup, and log which harness and settings you used. These logs — traces, test outcomes, correction counts, held constant across models — are what turn an impression into a real comparison, and they matter more than any single benchmark number for deciding whether Ornith fits your work.
Conclusion
Ornith-1.0 is DeepReinforce's open, MIT-licensed family of agentic coding models — four sizes from a 9B you can run on a laptop to a 397B flagship, distinguished by a self-scaffolding training approach where the model learns to build its own tool structure alongside solving tasks. It's weights, not a product: you download it from Hugging Face, run it through Ollama, vLLM, or LM Studio, and wire it into an agent yourself. The training idea is genuinely novel and the open, unrestricted release makes it broadly accessible, but read its benchmarks as DeepReinforce's own reported results — a reason to test it, not a verdict — and verify the current state of each variant, the license terms, and the data boundaries before running it on private code. For teams that want a locally-runnable open model for agentic coding and are set up to serve one, Ornith-1.0 is a genuinely interesting option to evaluate on your own tasks — which, as always with a new model, is where the real answer lives.
Related Reading
