Ornith (35B,9B) + Hermes,Zed: THE FULLY PRIVATE LOCAL AGENT is ACTUALLY HERE!

• Topic: Ornith, a new family of agentic coding models by Deep Reinforce.

• Key Features: Post-trained on Gemma and Qwen; focuses on coding, tool use, and agentic workflows; learns "scaffolds" (planning, retrying, error handling, tool use, etc.).

• Model Sizes: 9B, 35B, 397B.

• Benchmarks:

  • 397B: ~77 Terminal Bench, ~82 SweBench (comparable to Claude Opus).
  • 35B: ~64 Terminal Bench, ~75 SweBench.
  • 9B: ~43 Terminal Bench, ~69 SweBench.

• Technical Nuances: Reasoning models (need proper handling of reasoning tags/tool call blocks); risk of reward hacking (mitigated by fixed environments, monitoring, and LLM judges).

• Practical Advice: Use GGUF versions in LM Studio/Ollama for easy testing; ensure proper chat templates and parsers (vLLM/SGLang) to avoid broken tool calls.

• Personal Experience: Tested 35B with OpenCode and Hermes Agent; performs well with agents/tool calls; not great for general chat; better than Qwen 2.5 (implied by "Qwen 3.6" mention, though likely a typo for 2.5 or similar in transcript) in terms of stability/glitching.

  • Language: English (same as transcript).

  • Structure:

    1. Key Concepts.
    2. Main Topics & Key Points (Model Family, Scaffolding, Reward Hacking).
    3. Performance & Benchmarks (Data/Stats).
    4. Implementation & Technical Setup (Methodology/Framework).
    5. Real-world Testing & Observations (Case studies/Examples).
    6. Synthesis/Conclusion.

  • Key Concepts: Agentic coding models, Scaffolding, Post-training, Reward Hacking, Reasoning tags, Tool calling.

  • Main Topics:

    • Introduction to Ornith by Deep Reinforce.
    • The concept of "Scaffolding": It's not just about the answer, but the process (planning, retrying, error recovery, tool usage).
    • Addressing Reward Hacking: The danger of gaming benchmarks (hardcoding outputs). Mitigation: Fixed environments, monitoring, LLM judges.

  • Performance (Data):

    • 397B: 77 Terminal Bench, 82 SweBench.
    • 35B: 64 Terminal Bench, 75 SweBench.
    • 9B: 43 Terminal Bench, 69 SweBench.

  • Technical Setup:

    • Reasoning models require specific handling of reasoning tags and tool call blocks.
    • Failure to use correct templates/parsers leads to broken tool calls or raw text.
    • Recommended tools: LM Studio/Ollama (GGUF), vLLM/SGLang (with proper parsers).

  • Real-world Testing:

    • Tested with OpenCode and Hermes Agent.
    • Comparison: Better than Qwen in terms of stability (less glitchy).
    • Use case: Excellent for agents/tool calls, poor for general chat.
    • Example: An elevator simulator task (it went through all steps/files, even if the final result had issues).

  • Synthesis: Ornith is a significant step for local agentic coding due to its focus on process/scaffolding rather than just output.

  • Check against constraints: No "Summary of YouTube Video" intro. Use clear headings. Maintain technical precision. Ensure all 10 requirements are met.

  (Self-Correction during drafting): The transcript mentions "Qwen 3.6". While Qwen 2.5 is the current standard, I must stick to the transcript's content even if it seems like a typo, or phrase it carefully. I will use the transcript's terminology.

  • Key Concepts: Agentic Coding, Scaffolding, Reward Hacking, Post-training, Reasoning Tags.
  • Section 1: Overview of Ornith: Deep Reinforce, family of models (9B to 397B), based on Gemma and Qwen.
  • Section 2: The Scaffolding Approach: Focus on the process (planning, error recovery, tool use).
  • Section 3: Benchmarks: (Table/List format for clarity).
  • Section 4: Technical Implementation: Handling reasoning tags, importance of chat templates, recommended software.
  • Section 5: Practical Evaluation: Agent performance, comparison to Qwen, limitations (not for general chat).
  • Conclusion: Summary of takeaways.### Key Concepts

• Agentic Coding Models: Models specifically trained to act as agents, capable of using tools and following complex workflows to solve programming tasks.

• Scaffolding: The ability of a model to learn and implement the structural process of problem-solving (planning, retrying, error handling) rather than just providing a final answer.

• Post-training: The process of fine-tuning existing base models (in this case, Gemma and Qwen) for specific tasks like coding and tool use.

• Reward Hacking: A phenomenon where a model learns to "game" a benchmark by finding shortcuts (like hardcoding outputs) to achieve high scores without actually solving the underlying problem.

• Reasoning Tags/Tool Call Blocks: Specialized formatting used by reasoning models to separate internal thought processes from actionable tool commands.

Overview of the Ornith Model Family

Ornith is a new family of open agentic coding models developed by Deep Reinforce. Unlike base models trained from scratch, Ornith models are post-trained versions of Gemma and Qwen. The family scales from small, locally runnable models to massive enterprise-grade models:

• 9B Model: Optimized for local machines and lightweight servers.
• 35B Model: A balance between performance and local usability.
• 397B Model: A massive model designed for high-end performance, comparable to Claude Opus in certain metrics.

The "Scaffolding" Methodology

The core innovation of Ornith is its focus on scaffolding. The developers claim the models are trained not just to produce code, but to structure the entire process of reaching a solution. This includes:

• Planning: Determining the steps required to solve a task.
• Error Recovery: Learning how to retry and handle mistakes when a process fails.
• Tool Orchestration: Effectively using tools, checking files, and running tests.
• Workflow Management: Managing the "harness" or the agent loop, which the speaker notes is often as important as the model's raw intelligence.

Addressing Reward Hacking

To ensure the models are actually solving problems rather than just passing benchmarks, Deep Reinforce employs several mitigation strategies against reward hacking:

• Fixed Environments: Preventing the model from accessing external information that could lead to hardcoded answers.
• Monitoring: Keeping track of the model's actions.
• LLM Judge: Utilizing a secondary Large Language Model to act as a verifier to ensure the logic is sound and not just "gaming" the system.

Performance Benchmarks

The models demonstrate strong performance across key coding benchmarks:

| Model Size | Terminal Bench Score | SweBench Score | | :--- | :--- | :--- | | 397B | ~77 | ~82 | | 35B | ~64 | ~75 | | 9B | ~43 | ~69 |

Technical Implementation and Setup

Because Ornith is a reasoning model, users must be careful with their runtime environment. Improper setup can lead to "broken" experiences, such as raw reasoning text appearing in the output or failed tool calls.

Critical Setup Requirements:

• Chat Templates: Use the specific templates provided in the model card.
• Parsers: If using high-performance serving frameworks like vLLM or SGLang, ensure you use the correct reasoning and tool call parsers.
• Recommended Local Tools: For the easiest experience, the speaker recommends using GGUF versions via LM Studio or Ollama.

Real-World Testing and Observations

The speaker provided hands-on testing results using the 35B model:

• Agent Integration: The model performed well with OpenCode and Hermes Agent. It showed high stability in web search tool calls.
• Comparison to Qwen: The speaker noted that Ornith is less "glitchy" than Qwen (specifically referencing Qwen 3.6) when performing agentic tasks.
• Use Case Specificity:
  • Strengths: Excellent for agentic workflows and tool-heavy tasks.
  • Weaknesses: Not suitable for general chatting; it lacks the versatility of general-purpose models.
• Case Study: In an "elevator simulator" task, while the final result was imperfect, the model successfully navigated the complex process of creating files and executing multiple steps—a level of workflow management that was difficult to achieve in previous generations of models.

Synthesis and Main Takeaways

Ornith represents a shift in focus from pure "intelligence" to "process intelligence." By training models to build their own scaffolds, Deep Reinforce has created a family of models that are highly effective in agentic environments. For local users, the 9B and 35B models offer a significant leap in capability for coding assistants, provided the user implements the correct technical setup to handle the model's reasoning and tool-calling structures.