Ornith 1.0 Review: 9B to 397B, Benchmarks to Deployment

July 16, 2026 · 8 min read

DeepReinforce AI’s Ornith 1.0 family is one of the more unusual open-model releases of 2026. A four-model lineup — spanning a 6 GB laptop model and a 400 GB production cluster model — unified by a single self-scaffolding RL training method and a single claim: best-in-class agentic coding performance per parameter. This ornith 1.0 review covers all four models in full: what the benchmarks actually show, where deployment is smooth or rocky, and which model makes sense for your hardware and workload.

What Is Ornith 1.0?

Ornith 1.0 is an agentic coding model family released on June 25, 2026 by DeepReinforce AI under the MIT license. The defining technical feature is self-scaffolding reinforcement learning: rather than training a model to generate code and leaving orchestration to an external harness, DeepReinforce’s approach jointly optimizes the model’s solutions and the scaffolding logic — task planning, tool-call sequences, error recovery — in a single RL loop.

The family covers four size classes:

All models support the same 262,144-token context window. See full model specs for bf16 weights sizes and recommended quantizations.

MIT licensing with no regional restrictions means every model in the family is commercially usable without royalties.

Ornith 1.0 Review: Benchmark Results

All scores below are self-reported by DeepReinforce AI. Independent third-party verification was pending as of mid-2026, which is standard practice for new open model releases. That caveat noted, the numbers are detailed enough to be useful for relative comparisons.

Flagship: 397B vs Frontier Models

The pattern is clear: Ornith 397B beats Claude Opus 4.7 on both Terminal-Bench and SWE-Bench Verified, and substantially outperforms Qwen 3.5’s flagship on agentic tasks (77.5 vs 53.5 on Terminal-Bench). Claude Opus 4.8 is ahead on both benchmarks, and GLM-5.2-744B scores higher on Terminal-Bench (81.0 vs 77.5) — but the GLM model needs roughly twice the hardware.

Smaller Models vs Same-Tier Competition

Ornith 9B doubling Qwen 3.5 9B on Terminal-Bench (43.1 vs 21.3) is a significant result for a same-size comparison. The 35B MoE at 64.2 is the more remarkable number: it scores higher than anything in the 9B–31B dense tier while using only ~3B active parameters per token, which translates directly to faster inference. Read the ornith 9b vs 35b comparison for a side-by-side analysis.

The full benchmarks page has all scores in one place if you are building a comparison spreadsheet.

Model-by-Model Ornith 1.0 Review

Ornith 1.0-9B: Capable Edge Model

Best for: edge deployment, laptop coding assistants, fast triage tasks.

At ~6 GB Q4_K_M, the 9B fits a modern gaming GPU, an M-series Mac with 8 GB unified memory, or any machine where you need offline agentic inference. The 43.1 Terminal-Bench score is competitive with Gemma 4-31B despite being one-third the size — the self-scaffolding training clearly adds value even at small scale.

Limits: multi-file repository refactoring is unreliable, and long reasoning chains can lose coherence past a few sequential tool calls. See the detailed Ornith 9B review for hardware requirements and setup.

Ornith 1.0-31B: Dense Mid-Range

Best for: developers with a 24 GB GPU who want balanced quality without the MoE complexity.

At ~20 GB Q4, this fits comfortably on an RTX 3090 or 4090. It runs on a Gemma 4 base rather than Qwen 3.5, which gives it somewhat different strengths from the 9B and 35B siblings — particularly in instruction following. Performance data beyond the hardware specs is more limited in DeepReinforce’s release materials compared to the 9B and 35B, so the 31B is the least-characterized member of the family.

Ornith 1.0-35B MoE: Best Value in the Family

Best for: solo developers on consumer hardware who want the best accuracy-per-watt ratio.

The 35B MoE is the standout performer of the Ornith 1.0 family for most users. With ~3B active parameters per token, it runs faster than the 9B dense model at inference time while scoring 64.2 on Terminal-Bench and 75.6 on SWE-Bench Verified — both higher than any dense model below 397B. The ~25 GB Q5_K_M weight fits a single RTX 4090 or a Mac with 32 GB unified memory.

The trade-off: MoE models can have higher memory bandwidth requirements during loading, and the full 35B parameter space needs to be resident in VRAM even though only ~3B are active per step. Detailed setup is in the Ornith 35B MoE guide.

Ornith 1.0-397B: Production-Grade Flagship

Best for: teams running production pipelines who need maximum accuracy.

At ~200 GB FP8 or ~400 GB bf16, the 397B requires at least 8× 80 GB A100/H100 GPUs. The benchmark position — above Opus 4.7, below Opus 4.8, and well above open alternatives on agentic tasks — makes it a credible choice for organizations that already operate multi-GPU inference infrastructure. The Ornith 397B API guide covers hosted vs self-hosted options.

Deployment Maturity

This ornith 1.0 review would be incomplete without assessing how production-ready the tooling actually is.

Inference engines: vLLM and SGLang are both confirmed supported. Ollama works via GGUF for all models small enough to run locally. LM Studio and llama.cpp are supported for consumer deployments.

Tool calling: Works, but you must use the correct parser per framework. For vLLM: --enable-auto-tool-choice --tool-call-parser qwen3_xml. For SGLang: --tool-call-parser qwen3_coder. Mixing parsers is a common source of broken tool calls in agent pipelines.

Reasoning traces: Ornith models output reasoning in a separate reasoning_content field, keeping it cleanly separated from the final response. Most agent frameworks handle this transparently, but double-check if you are building a custom harness.

Agent framework compatibility: The OpenAI-compatible API means Ornith works with Claude Code, OpenHands, OpenClaw, and Hermes Agent out of the box — any framework that accepts an OpenAI-compatible endpoint.

Weights availability: GGUF, FP8, and bf16 weights are on HuggingFace. The how-to-run guide has exact commands for each deployment path.

The one maturity gap: independent benchmark verification was still pending as of June 2026. DeepReinforce’s self-reported numbers are internally consistent and methodologically described, but community reproduction at scale takes time.

Self-Scaffolding RL: What Makes Ornith Different

The core technical claim deserves examination. Most coding LLMs are trained on code corpora and fine-tuned on instruction-following data; the orchestration — task planning, tool invocation, retry logic — is handled by a separate external scaffold or agent framework.

Ornith’s self-scaffolding RL bakes that orchestration behavior into the model itself through a reinforcement learning process where the model jointly learns solutions and the scaffolding that surrounds them. This is paired with anti-reward-hacking mechanisms: a fixed trust boundary, a deterministic monitor, and a frozen LLM judge — all designed to prevent the model from finding benchmark shortcuts rather than learning genuine task-solving behavior.

Whether those anti-hacking mechanisms fully close the reward-hacking problem is something the broader research community will evaluate over time. What the benchmark gap between Ornith 9B and Qwen 3.5 9B suggests is that the training methodology does produce meaningfully different agent behavior, not just higher benchmark scores on the same underlying behavior.

Strengths and Weaknesses

Strengths:

• Strong agentic coding benchmarks across the full size range, especially Terminal-Bench
• 35B MoE is faster than the 9B dense at inference while scoring substantially higher
• MIT license with commercial use and no regional restrictions
• 262K context across all models
• Wide deployment support: vLLM, SGLang, Ollama, LM Studio, llama.cpp

Weaknesses:

• All benchmark scores self-reported; independent verification takes time
• The 31B dense model is undercharacterized relative to the 9B and 35B
• Tool calling requires the correct parser per framework — a friction point for new users
• No GPU = no good option; CPU inference is functional only for the smallest models
• Opus 4.8 is ahead on both headline benchmarks for users with API budget

Verdict by User Type

This ornith 1.0 review closes with a direct verdict for each situation:

Solo developer on a consumer GPU (24 GB VRAM): Run the 35B MoE. It is faster than the 9B, more accurate than the 31B, and fits on a single RTX 4090. The 35B setup guide covers everything.

Edge or laptop user (6–16 GB VRAM): The 9B Q4_K_M is the right pick. Check VRAM requirements and the Ollama setup guide for the fastest path to running it.

Mac with Apple Silicon: MLX via LM Studio runs the 9B or 35B (with 32 GB+ RAM) well. See the Ornith Mac MLX guide.

Production engineering team: The 397B is a serious competitor to Opus 4.7 at open-weights cost. Evaluate against your actual pipeline benchmarks; see Ornith 397B API options.

Users without dedicated GPU: Ornith is not the right fit. The models are optimized for GPU inference, and cloud API access is the only practical path — check the alternatives page for hosted options or smaller open models that run efficiently on CPU.

FAQ

Are Ornith 1.0 benchmark scores independently verified?

As of June 2026, all scores are self-reported by DeepReinforce AI. Independent community reproduction and third-party evaluations were underway but not yet published. The numbers are methodologically described and internally consistent, but applying the standard skepticism you would to any self-reported release is reasonable.

Which Ornith 1.0 model should I start with?

For most developers with a modern GPU, the 35B MoE is the best starting point: it delivers higher benchmark scores than the 9B at faster inference speed. If VRAM is constrained to 8–16 GB, start with the 9B. The models page has a quick reference for all four sizes.

Does Ornith 1.0 work with coding assistants like Claude Code or OpenHands?

Yes. All Ornith 1.0 models expose an OpenAI-compatible API endpoint when served via vLLM, SGLang, or Ollama. Claude Code, OpenHands, OpenClaw, and Hermes Agent connect without additional configuration beyond pointing to the local endpoint.

What is the license for Ornith 1.0 models?

MIT license, released by DeepReinforce AI. Commercial use is permitted with no regional restrictions. Standard MIT attribution requirements apply.

Closing

The ornith 1.0 review verdict: this is one of the strongest open agentic coding families available as of mid-2026. The 35B MoE in particular has an unusual combination of speed and accuracy that makes it the best-value model in the lineup and one of the most interesting open models at any size. The 397B flagship is a credible Opus 4.7 alternative for teams that run their own inference infrastructure. The benchmarks are self-reported and deserve the usual scrutiny — but the methodology is transparent and the gaps are large enough to be meaningful even with uncertainty margins. Start with the try page if you want to test Ornith before committing to a local setup.