Ornith-1.0: Deep Reinforce AI's Revolutionary Agentic Coding Models Redefine Open-Source AI Development

Crucially, feedback from the outcome is propagated back to both stages, allowing the model to optimize not just for better answers, but for more effective orchestration of the entire problem-solving process. Over repeated training, this creates a feedback loop where scaffolds are continually mutated and selected for their ability to induce higher-reward outcomes. The result is the emergence of per-task-category strategies without the need for hand-engineered harnesses, driving sustained improvements in capability and adaptability—especially when navigating complex, real-world codebases.

Innovations in Self-Improving Training

Central to Ornith-1.0’s breakthrough is its dynamic, self-improving training method, which marks a departure from static, human-crafted scaffolds and fixed strategies. Instead of relying solely on pre-designed frameworks to direct its problem-solving process, Ornith-1.0 actively learns not just how to produce solutions, but also how to construct the scaffolding that guides those solutions—essentially building its own playbook as it trains.

Here’s how it works:

• Each training cycle unfolds in two synergistic steps:

1. Scaffold Optimization: The model reviews the scaffold previously used for a task and proposes improvements or entirely new strategies tailored to the specifics of that task.
2. Solution Generation: With the refined scaffold in hand, it generates a solution rollout for the given problem.

• The rewards earned from the solution are allocated to both the scaffold creation and the answer generation, ensuring the model’s learning isn’t limited to just code quality, but extends to the way problems are approached and decomposed.

This feedback-driven process creates a continuous loop—scaffolds evolve alongside the model’s policy, mutating and adapting organically as training progresses. Over time, Ornith-1.0 uncovers per-task strategies that maximize performance, eliminating the need for manual intervention or rigid, one-size-fits-all templates. The result? A coding model capable of discovering innovative problem-solving pathways and producing higher-quality outcomes, tailor-made for each challenge it encounters.

Built upon Gemma 4 and Qwen 3.5 foundations, the architecture inherits robust multilingual capabilities and strong reasoning foundations.

• Four parameter variants: 9B Dense, 31B Dense, 35B MoE, 397B MoE
• Novel self-improving RL training optimizing both scaffolds and solutions
• Built on Gemma 4 and Qwen 3.5 base models
• Mixture-of-Experts architecture for efficient scaling
• Extended context window supporting complex codebases
• Multimodal capabilities for enhanced understanding

Performance & Benchmarks

Ornith-1.0 establishes new state-of-the-art records among open-source models, del...

The Role of the Frozen LLM Judge in Ornith-1.0's Reward System

In Ornith-1.0’s training pipeline, the frozen language model (LLM) judge serves as an impartial overseer layered atop the main verifier. Rather than being directly responsible for assigning rewards, this static judge acts as a safeguard, providing an independent check against attempts to manipulate the system within the approved tool interface. By stepping in as a final arbiter, the frozen judge helps prevent intent-level exploitation—where an agent designs solutions that satisfy superficial criteria without genuinely solving the problem. This additional layer ensures that approvals are based not just on immediate outputs but on a deeper evaluation of coding intent, contributing to the model's reliability and robustness during reinforcement learning.

Safeguards Against Reward Hacking in Self-Directed Learning

One of the most significant challenges in autonomous model improvement is reward hacking—the crafty tendency for a model to “game the system” and maximize its training signals through shortcuts rather than genuine problem-solving. Ornith-1.0 tackles this head-on with a robust, multi-pronged defense that ensures true learning and authentic progress.

Here's how Ornith-1.0 keeps self-improvement honest:

• Immutable Trust Boundaries: The core environment, including accessible files, tools, and isolated test conditions, is locked down. Ornith-1.0 is only allowed to modify its internal strategies (like memory management and orchestration), preventing it from manipulating the external evaluation setup for easy wins.
• Deterministic Monitoring: A rule-bound monitor oversees the model’s every move, rigorously enforcing these boundaries. Attempts to peek at restricted files, alter verification scripts, or take unsanctioned actions are flagged immediately. Such actions are denied any training benefit (zero reward)—removing incentives for mischief.
• Human-Like Judgment Layer: To address subtler forms of system-gaming that can slip through technical checks, Ornith-1.0 leverages a frozen language model “referee.” This additional judge scrutinizes outputs for intent, stepping in when a solution passes mechanical tests but fails the spirit of the task.

Through these layered defenses, Ornith-1.0 ensures its self-improvement is built on genuine skill, not loopholes or sleight of hand.

Tackling Off-Policy Challenges with Pipeline-RL

Central to Ornith-1.0’s cutting-edge training regime is its pipeline-RL strategy—a novel approach designed to handle the longstanding issue of off-policy drift during long reinforcement learning rollouts. In standard RL setups, models can accumulate outdated context as they generate longer sequences, causing the quality of policy updates to degrade. Ornith-1.0 sidesteps this pitfall by introducing a dynamic weighting system for generated tokens based on their age within a rollout.

Here’s how it works:

• Age-Based Weighting: Tokens generated earlier in a rollout are assigned less influence on the learning process as they become "stale." If a token surpasses a certain age threshold, its contribution is fully discarded.
• Careful Balancing: Recent tokens—which better reflect the model’s current policy—are given full weight. As tokens age, their impact is smoothly reduced using an exponential decay, ensuring only the most relevant experience shapes the model’s policy updates.
• Improved Policy Learning: This approach minimizes the detrimental effect of outdated or off-policy actions while still leveraging valuable experiences, allowing Ornith-1.0 to learn more robust, on-policy behaviors—even in complex, multi-phase coding scenarios.

By fine-tuning how experiences contribute to learning, pipeline-RL enables consistent optimization without succumbing to the pitfalls of stale data—a crucial advantage when developing an autonomous coding agent meant to handle intricate, real-world codebases.

Safeguarding Training: Enforcing Boundaries and Preventing Reward Hacking

Maintaining the integrity of agentic coding models like Ornith-1.0 demands rigorous safeguards against unintended behaviors or "reward hacking" during training—where the model might exploit loopholes rather than genuinely solving tasks. Ornith-1.0 addresses this challenge through a robust, layered defense strategy:

• Immutable Environment Boundaries: The foundational layer ensures that critical aspects of the coding environment—such as test file access, tool interfaces, and the isolation of evaluation scripts—are entirely outside the model's influence. By clearly separating immutable environment elements from the model's internal decision-making, Ornith-1.0 restricts the scope of potential manipulation, allowing only the inner workings of its policy (like memory management and orchestration) to evolve.
• Deterministic Behavioral Monitoring: To prevent unauthorized behavior, Ornith-1.0 employs a deterministic monitor that scrutinizes every action taken by the model during training. This monitor flags attempts to access restricted files, tamper with verification scripts, or perform out-of-bounds actions. Actions that violate these constraints are assigned no reward and are excluded from further learning advantage—a zero-tolerance approach to policy accidents.
• Intent Verification with Independent Adjudication: Recognizing that clever models might still game the system within allowed actions, Ornith-1.0 enlists an independent, “frozen” language model as a final judge. This external model audits each solution at an intent level, vetoing any behavior that appears exploitative or inconsistent with genuine problem-solving, even if it passes the initial verifier.

Through this multi-tiered approach, Ornith-1.0 not only secures robust and honest learning but sets a new standard for agentic coding model training—empowering the model to explore and adapt while keeping its creativity firmly on track. Built upon Gemma 4 and Qwen 3.5 foundations, the architecture inherits robust multilingual capabilities and strong reasoning foundations.

Reinforcement Learning: Addressing Staleness and Token-Level Losses

A key innovation in Ornith-1.0’s training pipeline lies in how it handles the so-called “staleness” issue during reinforcement learning, especially for long generation sequences. As with any model leveraging off-policy data in extended rollouts, earlier tokens can become outdated or misaligned with the current training objective. Ornith-1.0 counters this with a dynamic staleness weighting mechanism.

Here’s how it works:

• Staleness Weights: Each generated token is assigned a weight based on its “age” (how long ago it was produced relative to the current policy). Recent tokens receive full weighting, but as tokens get older, their influence fades—first gradually decreasing, then being disregarded entirely after a certain threshold. This approach ensures that model updates focus on fresher, more relevant experiences during training.
• Token-Level Loss Application: When optimizing with reinforcement learning, the model’s loss for each token is modulated by the staleness weight. This means that newer tokens contribute more significantly to policy updates, while older or outdated examples have their impact reduced or nullified. The process also integrates careful reward clipping, ensuring the model learns from meaningful feedback without being distorted by outliers.

By combining staleness-aware weighting with precise loss calculation, Ornith-1.0 maintains training stability and ensures that its improvements remain grounded in up-to-date behaviors, not drift-prone or obsolete data.

• Four parameter variants: 9B Dense, 31B Dense, 35B MoE, 397B MoE
• Novel self-improving RL training optimizing both scaffolds and solutions
• Built on Gemma 4 and Qwen 3.5 base models
• Mixture-of-Experts architecture for efficient scaling
• Extended context window supporting complex codebases
• Multimodal capabilities for enhanced understanding

Performance & Benchmarks

Ornith-1.0 establishes new state-of-the-art records among open-source models, delivering benchmark scores that challenge proprietary leaders. The 397B MoE variant achieves 77.5 on Terminal-Bench 2.1 and 82.4 on SWE-Bench Verified, directly matching Claude Opus 4.7's 70.3 and 80.8 respectively. This performance parity with Anthropic's flagship model represents a watershed moment for open-source AI development, proving that community-driven innovation can compete at the highest levels.

When compared against other open-source models, Ornith-1.0's superiority becomes even more evident. The 397B MoE outperforms MiniMax M3 (66.0 TB-2.1, 80.5 SWE-Bench Verified) and DeepSeek-V4-Pro (67.9 TB-2.1, 80.6 SWE-Bench Verified) across all major coding benchmarks. Perhaps most impressively, the compact 9B Dense model matches or exceeds the performance of much larger models like Gemma 4-31B and Qwen 3.6 35B, demonstrating exceptional efficiency in parameter utilization.

Ornith-1.0-35B vs. Peer and Larger Models

The Ornith-1.0-35B model stands out not just against the competition in its own weight class, but even when facing much larger contenders. Notably, it outpaces both Qwen 3.5-35B, Qwen 3.6-35B, and Gemma 31B—established benchmarks among 30B-35B models—delivering stronger coding and agentic performance across the board. Remarkably, despite operating at just 35B parameters, Ornith-1.0-35B even edges out Qwen 3.5-397B on Terminal-Bench 2.1 (64.4 compared to 53.5), showcasing a level of efficiency and optimization that allows it to challenge—and in some cases surpass—models an order of magnitude larger. Across multiple evaluation metrics, Ornith-1.0-35B consistently matches or exceeds the capabilities of its much bigger rivals, underscoring the effectiveness of its self-improving architecture and efficient parameter utilization.

The benchmark suite showcases comprehensive coding proficiency: 77.5 on Terminal-Bench 2.1, 82.4 on SWE-Bench Verified, 62.2 on SWE-Bench Pro, 78.9 on SWE-Bench Multilingual, 48.2 on NL2Repo, and 41.2/42.6/39.1 on SWE Atlas (QnA/RF/TW). Additionally, ClawEval scores of 77.1 demonstrate strong repository-level understanding and manipulation capabilities.

• Terminal-Bench 2.1: 77.5 (matches Claude Opus 4.7)
• SWE-Bench Verified: 82.4 (matches Claude Opus 4.7)
• SWE-Bench Pro: 62.2
• SWE-Bench Multilingual: 78.9
• NL2Repo: 48.2
• SWE Atlas: 41.2 QnA / 42.6 RF / 39.1 TW
• ClawEval: 77.1
• Outperforms MiniMax M3 and DeepSeek-V4-Pro

Evaluation Protocols & Benchmark Configurations

To ensure rigor and reproducibility across benchmarks, Ornith-1.0 is assessed under carefully controlled evaluation settings tailored for each task. Below is an overview of the evaluation setups:

• Terminal-Bench 2.1: Runs utilize the Harbor/Terminus-2 suite with a 128K context window, parser set to JSON, temperature at 1.0, and top-p at 1.0. Evaluations are conducted over five trials, each allowing up to four hours, leveraging 32 CPU cores and 48GB RAM. For code generation comparisons with Claude Code 2.1, the max output is extended to 131,072 tokens, maintaining identical sampling parameters.
• SWE-Bench (Verified, Pro, Multilingual): All SWE-Bench variants are evaluated via the OpenHands harness, with temperature at 1.0, top-p at 0.95, and an expanded 256K context window. This setup ensures thorough coverage of reasoning and multilingual capabilities.
• SWE Atlas (QnA, RF, TW): Mini SWE agent environments are used for these tasks, standardizing on temp=1.0, top-p=0.95, and a 128K context window. Scores reflect averages across five independent runs for each configuration.
• NL2Repo: Natural language to code repository generation tests use temperature=1.0, top-p=1.0, a substantial 400K context window, and accommodate up to 48K output tokens. Additional anti-hacking filters are enabled to safeguard against unintended exploits.
• ClawEval: This benchmark focuses on agentic code generation across authentic user task sets, operating at temperature 0.6 and a 256K context window to balance creativity with reliability.

All evaluations are purposefully aligned with current research best practices, enabling transparent comparison with both open-source and proprietary models.

Fine-Grained Benchmark Comparison

A closer look at model variants further underscores Ornith-1.0’s versatility:

Ornith-1.0-397B
Not only does the 397B MoE variant rival flagship proprietary models, but it also outpaces similarly sized open-source competitors. For example, it posts 78.2 on Terminal Bench 2.1 (Claude Code) and 62.2 on SWE-Bench Pro, while maintaining top-tier performance across multilingual and repository-based benchmarks.

Ornith-1.0-35B
With only 35B parameters, this model outperforms Qwen 3.5-35B and Gemma 31B, and even surpasses Qwen 3.5-397B on Terminal-Bench 2.1 (64.2 vs. 53.5). It demonstrates that strong agentic coding performance is achievable without frontier-scale compute.

Ornith-1.0-9B
The edge-deployable 9B Dense model achieves 43.1 on Terminal-Bench 2.1 and 69.4 on SWE-Bench Verified, rivaling much larger models such as Gemma 4-31B. Its strong scores on ClawEval, NL2Repo, and across SWE Atlas categories confirm that resource-efficient deployments don’t require sacrificing capability.

Benchmark Tables

Benchmark Ornith-1.0-397B Qwen3.5-397B Claude Opus 4.7 MiniMax M3 DeepSeek-V4-Pro 
Terminal Bench 2.1 (Terminus-2) 77.5 53.5 70.3 66.0 67.9 
SWE-Bench Verified 82.4 76.4 80.8 80.5 80.6 
SWE-Bench Pro 62.2 51.6 64.3 59 55.4 
SWE-Bench Multilingual 78.9 69.3 — — 76.2 NL2Repo 48.2 36.8 — 42.1 — 
ClawEval Avg 77.1 70.7 78.2 — 75.8 
SWE Atlas (QnA / RF / TW) 41.2 / 42.6 / 39.1 20.4 / 18.4 / 18.5 40.3 / 48.6 / 38.5 37.9 / — / 30.8 27.2 / — / —

Benchmark Ornith-1.0-35B Qwen3.5-35B Gemma4-31B Qwen3.5-397B 
Terminal Bench 2.1 (Terminus-2) 64.2 41.4 42.1 53.5 
SWE-Bench Verified 75.6 70.0 52.0 76.4 
SWE-Bench Pro 50.4 44.6 35.7 51.6 
SWE-Bench Multilingual 69.3 60.3 51.7 69.3 NL2Repo 34.6 20.5 15.5 36.8 ClawEval Avg 69.8 65.4 48.5 70.7 
SWE Atlas (QnA / RF / TW) 37.1 / 29.7 / 27.8 13.2 / 10.2 / 9.8 — 20.4 / 18.4 / 18.5

Benchmark Ornith-1.0-9B Qwen3.5-9B Gemma4-12B Gemma4-31B 
Terminal Bench 2.1 (Terminus-2) 43.1 21.3 21.0 42.1 
SWE-Bench Verified 69.4 53.2 44.2 52.0 
SWE-Bench Pro 42.9 31.3 27.6 35.7 
SWE-Bench Multilingual 52.0 39.7 32.5 51.7 NL2Repo 27.2 16.2 10.3 15.5 
ClawEval Avg 63.1 53.2 32.5 48.5 
SWE Atlas (QnA / RF / TW) 17.9 / 16.6 / 15.3 9.2 / 4.3 / 4.4 — — 
Ornith-1.0’s comprehensive results demonstrate not only a leap in open-source agentic coding but also a new standard for efficient, scalable deployment—whether at the edge or the frontier.

API Pricing

As of the initial release, specific API pricing details for Ornith-1.0 have not yet been published on Deep Reinforce AI's official documentation pages. The company has indicated that pricing information will be made available through their developer portal and API documentation in the coming weeks. Given the open-source nature of the models and the competitive landscape, developers can expect transparent and accessible pricing structures that align with the MIT licensing philosophy.

For organizations preferring direct API access over self-hosting, Deep Reinforce AI will likely offer tiered pricing based on token consumption, with potential free tiers for evaluation and development purposes. The company's commitment to open-source principles suggests they may adopt competitive pricing strategies to encourage widespread adoption and community contribution.

• Official pricing pending announcement
• Expected transparent token-based pricing
• Likely free tier for development use
• MIT license enables self-hosting alternatives

Use Cases

Ornith-1.0 excels in agentic coding scenarios where autonomous problem-solving and iterative refinement are essential. Developers can deploy the models for automated code generation, bug fixing, refactoring assistance, and architectural design guidance. The 9B Dense variant is particularly well-suited for edge deployment in IDE integrations, real-time code suggestions, and mobile development environments where latency and resource constraints matter.

Beyond pure coding tasks, Ornith-1.0's agentic capabilities extend to complex reasoning workflows, documentation generation, test case creation, and technical debt analysis. The models perform exceptionally well in RAG (Retrieval-Augmented Generation) applications when processing large codebases, thanks to their extended context windows and superior repository understanding demonstrated on ClawEval. Enterprise teams can leverage the full suite for automated code review systems, security vulnerability detection, and compliance checking across multilingual codebases.

• Automated code generation and refactoring
• Bug detection and fixing workflows
• IDE integration and real-time suggestions
• Repository-level analysis and understanding
• Multilingual codebase processing
• Security and compliance automation
• Technical documentation generation

Getting Started

Developers can access Ornith-1.0 models through multiple channels. The primary entry point is Deep Reinforce AI's official model hub at https://huggingface.co/deepreinforce, where all four variants are available for immediate download under MIT license. For API-based integration, the company provides RESTful endpoints with comprehensive SDKs for Python, JavaScript, and Go, enabling seamless incorporation into existing development workflows.

The models support standard transformer architectures and can be deployed using popular frameworks like Transformers, vLLM, and TGI. Detailed documentation including installation guides, API references, and best practices are available at https://docs.deepreinforce.ai/ornith-1.0. The 9B Dense model serves as an excellent starting point for experimentation, while production deployments can scale to the 397B MoE variant for maximum performance. Community support is available through Discord channels and GitHub discussions, fostering collaborative development and knowledge sharing.

• Available on HuggingFace under MIT license
• RESTful API endpoints with Python/JavaScript/Go SDKs
• Compatible with Transformers, vLLM, TGI frameworks
• Documentation at docs.deepreinforce.ai/ornith-1.0
• Community support via Discord and GitHub
• 9B Dense ideal for getting started quickly

Sources