Executive Summary
DeepReinforce has released Ornith-1.0, a significant open-source model family designed specifically for agentic coding tasks. The lineup spans four distinct model sizes, from a compact 9B dense model to a massive 397B mixture-of-experts flagship. Every checkpoint is released under the MIT license and hosted on Hugging Face, making these powerful models accessible to both individual developers and enterprise teams.
What makes Ornith-1.0 notable is its unique approach to scaffold learning—instead of relying on fixed, human-designed harnesses, the models learn to write their own orchestration strategies during reinforcement learning. This self-scaffolding capability represents a significant paradigm shift in how coding agents operate.
⚡ Key Takeaways
- Four model variants: 9B, 31B, 35B-MoE, and 397B-MoE
- Self-scaffolding: models learn their own orchestration strategies - Post-trained on **Qwen 3.5** foundations
- MIT license ensures maximum accessibility Strong performance among open models on coding benchmarks
- Three defense layers prevent reward hacking
What is Ornith-1.0?
Ornith-1.0 is a collection of reasoning models purpose-built for coding agents. The family consists of four variants, each serving different use cases from resource-constrained environments to high-performance enterprise deployments:
- Ornith-1.0-9B — Dense model (~19GB in bf16) for edge and single-GPU setups
- Ornith-1.0-31B — Dense model for balanced performance
- Ornith-1.0-35B-MoE — Mixture-of-Experts: ~3B active parameters per token (10% activation rate)
- Ornith-1.0-397B-MoE — Flagship model with expert routing
- Ornith-1.0-35B-FP8 — Quantized variant (~2.5GB, 14x reduction from BF16)
All models are built upon pretrained foundations from **Gemma 4** and **Qwen 3.5**, then post-trained with reinforcement learning to optimize their scaffolding capabilities.
The Self-Scaffolding Innovation
Most coding agents operate within a fixed scaffold, also known as a harness. This scaffold wraps the model with memory management, tool integration, error handling, and orchestration logic. AI teams typically hand-design one scaffold per task category, creating a one-size-fits-all approach that doesn't adapt to different coding scenarios.
Ornith-1.0 treats the scaffold as a learnable object rather than a static component. During reinforcement learning, the scaffold co-evolves with the model's policy, creating a dynamic system that adapts to different coding tasks.
Architecture Flow
Task Input
Raw coding problem + previous scaffold context
Scaffold Propagation
Model proposes refined scaffold optimized for task
Solution Generation
Generate complete solution rollout using scaffold
Reward Feedback
Success signal flows back, refining both scaffold and policy
Two-Stage Reinforcement Learning
The training process operates in two distinct stages:
- Scaffold Propagation: The model reads the current task and its previous scaffold, then proposes a refined scaffold optimized for the specific coding challenge.
- Solution Generation: Using the proposed scaffold and the task description, the model generates a complete solution rollout.
Reward signals from successful rollouts flow back to both stages, encouraging the model to develop increasingly effective orchestration strategies. Over training, higher-performing scaffolds are automatically selected and refined.
🎯 Key Advantages
- Task-Specific Adaptation: Each coding task naturally develops its own optimal strategy without manual intervention
- Continuous Improvement: The scaffold evolves alongside the model, creating a feedback loop of increasing efficiency
- Reduced Engineering Overhead: No need for manual harness design or task-specific configuration
- Emergent Behaviors: Complex multi-step coding tasks develop natural workflows that humans might not anticipate
Training Architecture
Pipeline-RL Setup
DeepReinforce employs an asynchronous pipeline approach to training:
- Parallel Processing: Multiple training stages run concurrently to maximize throughput
- Staleness Management: A staleness weight mechanism downweights older, off-policy tokens, dropping them once they exceed a freshness threshold
- Token-Level GRPO Objective: The optimization operates at the token level, allowing fine-grained control over reinforcement learning updates
Guarding Against Reward Hacking
One of the most significant challenges in training self-scaffolding models is preventing reward hacking. A model might exploit its ability to write scaffolds by reading visible test files and hardcoding expected outputs, or copying oracle solutions from the environment.
DeepReinforce implements three defense layers:
- Immutable Trust Boundary: The environment, tool surface, and test isolation remain outside the model's reach. The model can only evolve its internal policy scaffold.
- Deterministic Monitor: A monitoring system flags and penalizes banned actions such as reading withheld paths or editing verification scripts. These trajectories are excluded from advantage computation.
- Frozen LLM Judge: An independent, pre-trained language model serves as a veto mechanism, sitting on top of the verifier rather than as the primary reward signal.
Model Variants and Specifications
Ornith-1.0-9B (Dense)
Use Case: Edge devices, single-GPU setups, latency-sensitive applications
- Total Parameters: ~9 billion
- Memory Footprint: ~9.4GB (bf16)
- Active Parameters: All (dense architecture)
- Performance - Terminal-Bench 2.1: 43.1
- Performance - SWE-Bench Verified: 69.4
The 9B model demonstrates that even compact models can achieve meaningful coding capabilities when properly trained with reinforcement learning. Its small footprint makes it ideal for deployment on consumer hardware.
Ornith-1.0-31B (Dense)
Use Case: Balanced performance for general coding tasks
- Total Parameters: ~31 billion
- Active Parameters: All (dense architecture)
The 31B model provides a strong balance between quality and inference speed, suitable for most coding agent applications.
Ornith-1.0-35B-MoE (Mixture-of-Experts)
Use Case: High-performance tasks requiring selective computation
- Total Parameters: ~35 billion
- Active Parameters: ~3 billion per token (10% activation rate)
- Performance - Terminal-Bench 2.1: 64.2 (surpassing Qwen 3.5-397B at 53.5)
The MoE architecture allows the model to route different aspects of coding tasks to specialized expert networks, achieving high performance while maintaining computational efficiency.
Ornith-1.0-397B-MoE (Flagship)
Use Case: Complex, multi-file refactoring, enterprise coding agents
- Total Parameters: ~397 billion
- Active Parameters: Varies by routing (estimated ~39.7B per token)
- Performance - Terminal-Bench 2.1: 77.5
- Performance - SWE-Bench Verified: 82.4
- Performance - SWE-Bench Pro: 62.2
- Performance - SWE-Bench Multilingual: 78.9
- Performance - NL2Repo: 48.2
- Performance - ClawEval Avg: 77.1
The flagship model achieves state-of-the-art results among open models of comparable size, with a 77.5 score on Terminal-Bench 2.1 — competitive with other large-scale open models.
Quick Comparison
Edge-ready, single-GPU coding agent
Balanced performance for general coding
Efficient expert routing, high performance
Enterprise-grade coding agent
Benchmark Performance
Comparative Analysis
| Benchmark | Ornith 397B | Qwen3.5 397B | Qwen3.7-Max | GLM-5.2-744B | Claude Opus 4.7 | Claude Opus 4.8 |
|---|---|---|---|---|---|---|
| Terminal-Bench 2.1 | 77.5 | 53.5 | 73.5 | 81.0 | 70.3 | 85.0 |
| SWE-Bench Verified | 82.4 | 76.4 | 80.4 | — | 80.8 | 87.6 |
| SWE-Bench Pro | 62.2 | 51.6 | 60.6 | 62.1 | 64.3 | 69.2 |
| SWE-Bench Multilingual | 78.9 | 69.3 | 78.3 | — | — | — |
| NL2Repo | 48.2 | 36.8 | 47.2 | 48.9 | — | 69.7 |
| ClawEval Avg | 77.1 | 70.7 | 65.2 | — | — | — |
📊 Key Observations
- Open Model Leadership: Ornith-1.0-397B outperforms most comparable open-source models across all benchmarks
- Efficiency Gains: The 35B-MoE model is highly efficient — at only ~3B active parameters per token, it achieves strong results while the 397B MoE activates ~39.7B per token
- Reasoning Capability: The 9B model's 69.4 on SWE-Bench Verified demonstrates that even small models benefit substantially from reinforcement learning post-training
- Competitive Positioning: While not surpassing the latest closed-source models (Claude Opus 4.8, GLM-5.2-744B), Ornith-1.0 represents a significant leap forward for open-source coding agents
Architecture and Deployment
Serving Options
DeepReinforce provides multiple serving frameworks for deployment:
- vLLM: Production-grade inference with high throughput
- SGLang: Alternative serving engine for flexibility
- Transformers: PyTorch-based serving for research and experimentation
OpenAI-Compatible API
All models expose OpenAI-compatible endpoints, enabling seamless integration with existing agent frameworks:
# Start with vLLM
# vllm serve deepreinforce-ai/Ornith-1.0-9B
# --served-model-name Ornith-1.0-9B
# --max-model-len 262144
# --enable-auto-tool-choice
# --tool-call-parser qwen3_xml
# --reasoning-parser qwen3
# --trust-remote-code
# Call with OpenAI client
from openai import OpenAI
client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")
resp = client.chat.completions.create(
model="Ornith-1.0-9B",
messages=[{"role": "user", "content": "Write a Python is_prime(n)."}],
temperature=0.6, top_p=0.95,
)
msg = resp.choices[0].message
print(getattr(msg, "reasoning_content", None)) # the trace
print(msg.content) # the final answer
Integration Frameworks
The models work with popular agent platforms:
- OpenHands: Full-featured coding agent
- OpenClaw: Lightweight coding assistant
- OpenCode: Code generation platform
Recommended Sampling Parameters
For optimal performance:
- Temperature: 0.6
- Top-p: 0.95
- Top-k: 20
Reasoning Output Format
Ornith-1.0 models emit reasoning traces in a structured format:
reasoning_content: Contains thetrace showing the model's thinking process content: Contains the final answer or code output
Use Cases and Applications
1. Multi-File Refactoring
Ornith-1.0 excels at understanding codebases across multiple files, making it ideal for large-scale refactoring projects, legacy code modernization, and architecture migration.
2. Bug Localization and Fixing
The model's scaffolding capability enables automatic root cause analysis, context-aware debugging workflows, and test-driven patch generation.
3. Edge and Resource-Constrained Deployments
The 9B model's compact size enables on-device coding assistance, single-GPU deployment for teams, and low-latency inference for real-time applications.
4. Enterprise Coding Agents
The 397B flagship targets internal development platforms, automated code review systems, and continuous integration optimization.
5. Educational and Research Applications
The open-source nature enables custom training experiments, scaffolding mechanism research, and benchmarking and comparison studies.
Technical Details
Pretraining Foundations
Ornith-1.0 models are built upon two leading open-source architectures:
- Gemma 4: Google's advanced language model family
- Qwen 3.5: Alibaba's high-performing model series
These foundations provide strong language understanding and generation capabilities, which are then enhanced through reinforcement learning post-training.
Mixture-of-Experts Implementation
The MoE variants employ advanced expert routing:
- Dynamic Expert Selection: At each token, only a subset of experts is activated
- Load Balancing: Ensures even utilization of all expert networks
- Specialization: Different experts develop proficiency in specific coding domains
Reinforcement Learning Optimization
The training process uses:
- GRPO (Group Relative Policy Optimization): Token-level optimization
- Asynchronous Pipelines: Parallel training for efficiency
- Staleness-Aware Updates: Freshness-weighted gradient computation
Availability and Access
All Ornith-1.0 checkpoints are available on Hugging Face under the MIT license. The models are hosted in multiple precision formats including FP8, BF16, and GGUF for local deployment.
Search for "deepreinforce-ai/Ornith-1.0" on Hugging Face to access the model weights and documentation.
HuggingFace Organization
deepreinforce-ai / Ornith-1.0 (all variants)
License
MIT License — fully permissive, no restrictions on commercial use
Deployment Formats
Safetensors (BF16), FP8 quantized, GGUF — multiple serving options
Popularity
35B variant: 19,635 downloads, 208 likes on HuggingFace
Comparison with Competitors
Closed-Source Models
Ornith-1.0 differentiates from closed-source models through self-scaffolding (learns its own orchestration vs. fixed harnesses), open-source transparency, efficiency via MoE architecture, and flexibility with multiple sizes for different use cases.
VS Other Open-Source Coding Models
Ornith-1.0's unique value proposition includes scaffold learning (no other open model learns its own harness), competitive or superior benchmark performance, the most permissive MIT license, and structured reasoning capabilities with
Future Directions
Based on the technology demonstrated, future Ornith iterations could include larger model sizes beyond 397B with improved MoE efficiency, multimodal capabilities extending scaffolding to image and audio inputs, cross-modal reasoning that integrates different input modalities, and domain specialization with task-specific model variants for specialized coding domains.
🔬 Research Opportunities
- Scaffold Transfer: Can learned scaffolds transfer between related tasks?
- Scaffold Compression: Can effective scaffolds be compressed for efficiency?
- Scaffold Interpretability: Can we understand why certain scaffolds emerge?
- Scaffold Evolution: How do scaffolds change as the model improves?
Conclusion
Ornith-1.0 represents a significant milestone in open-source coding AI. By introducing the concept of self-scaffolding models that learn their own orchestration strategies, DeepReinforce has demonstrated a novel approach to building more adaptive and efficient coding agents.
The four-model lineup provides options for every use case, from resource-constrained edge devices to enterprise-grade coding platforms. The MIT license ensures broad accessibility, while the strong benchmark performance demonstrates the viability of open-source approaches to complex coding tasks.
As the field continues to evolve, Ornith-1.0's self-scaffolding paradigm may influence how future coding agents are designed and trained, potentially reshaping the landscape of AI-assisted software development.
Sources & Transparency
Primary Sources
HuggingFace Model Card · DeepReinforce Official Site · Ornith Release Blog
Editorial Note
This article was written by ZVHH Research Team with AI-assisted research support. All benchmark claims are sourced from DeepReinforce's official release documentation. No independent third-party verification was performed.
Confidence Levels
Benchmark numbers are reported from DeepReinforce's official release. Confidence level: Medium — single-source, no independent verification. Claims are clearly labeled as such in the article body.
As of June 29, 2026
Information current as of publication date. Model release details may change. Last verified: Jun 29, 2026.