Overview
Sam Witteveen introduces Ornith 1.0, a family of open-weight agentic coding models from Deep Reinforce that take a fundamentally different approach to AI-powered coding. Instead of relying on human-designed agent harnesses, Ornith models learn to write their own scaffolding — generating both the task-specific harness and the solution in a single pass. Built on Qwen 3.5 and Gemma 4 base models and trained via a novel two-stage GRPO process, these "self-scaffolding LLMs" represent a paradigm shift: the model doesn't just code — it codes the system that helps it code.
1 The Ornith 1.0 Model Family
Ornith 1.0 arrives as a family of four models, all fine-tuned (mid-training and post-training) rather than pre-trained from scratch. The base models come from two families:
- Ornith 9B — based on Qwen 3.5, the smallest and most accessible option for local deployment
- Ornith 31B — based on Gemma 4, a dense model offering a good balance of capability and efficiency
- Ornith 35B MoE — based on Qwen 3.5, a Mixture-of-Experts model that punches above its active parameter count
- Ornith 397B MoE — based on Qwen 3.5, the flagship model that competes with frontier proprietary offerings
Critically, unlike some recent releases that withhold the largest model, Deep Reinforce has released all four models as open weights — including the 397B flagship. Sam emphasizes this openness, noting it arrives alongside news of GPT-5.6 facing government usage restrictions, highlighting the growing importance of the open-weight ecosystem.
2 Self-Scaffolding Architecture
The core innovation that defines Ornith is the concept of self-scaffolding LLMs for agentic coding. Traditionally, agent harnesses (the scaffolding, tools, and execution pipelines that guide an LLM through a task) are designed by humans. Ornith flips this: the model itself learns to generate task-specific harnesses on the fly.
The key insight is treating the agent harness as a learnable object rather than a fixed human-authored component. When presented with a task, an Ornith model:
- Analyzes the task requirements — understands what kind of scaffolding would be optimal
- Generates a custom harness — writes the specific tools, pipelines, and execution logic needed
- Produces the solution — uses its self-generated harness to complete the actual coding task
Sam frames this as the model learning to do context engineering instead of requiring humans to write that by hand. If a particular use case needs one kind of harness, the model can write that on the fly and then use it to produce better results.
3 Two-Stage Reinforcement Learning Training
The training process that makes self-scaffolding possible is a two-stage iterative RL loop using GRPO (Group Relative Policy Optimization). Here's how it works:
Stage 1: Scaffold Generation
The model is given a task along with a previously-used scaffold for that type of task. It then proposes a new, refined version of the scaffold — improving on what came before.
Stage 2: Solution Rollout
Conditioned on the newly generated harness, the model produces the actual solution — the agentic trajectory that executes the coding task.
Reward Signal & Weight Updates
Multiple rollouts are generated and evaluated. The outcomes serve as a reward signal that updates the model's weights for both capabilities simultaneously: generating better scaffolds AND generating better solutions within those scaffolds. The key is that both the harness quality and the final result quality are optimized jointly through GRPO's reward mechanism.
4 Defending Against Reward Hacking
A natural question arises: if the model controls both the harness and the solution, why doesn't it just cheat? It could theoretically build a harness that takes a shortcut to the "right" answer without actually solving the problem. Deep Reinforce addresses this with three layers of defense:
Layer 1: Immutable Environment
The sandbox environment, tools, and infrastructure are completely immutable. The model cannot modify the execution environment to create shortcuts — all system-level components are locked down and read-only.
Layer 2: Deterministic Monitor
A deterministic monitoring system watches what the scaffolding actually does in real-time. It checks whether the scaffold attempts to:
- Modify verification scripts
- Use unsanctioned tools outside its allowed set
- Access anything outside the sandbox boundary
Any violation triggers an immediate penalty in the reward signal.
Layer 3: LLM-as-Judge Veto
Even if the scaffold passes the first two layers, an LLM-as-judge can veto the entire verification. If the judge determines the result was achieved through an impermissible method, it overrides the GRPO reward signal entirely. This catches subtle gaming strategies that rule-based monitors might miss.
Sam draws a parallel to the early days of RLHF/RLAIF, where generator models found bizarre exploits (repeating tokens, producing gibberish) that tricked weaker reward models. Ornith's three-layer approach is specifically designed to prevent this class of issues.
5 Benchmark Results
Across the model family, the benchmarks tell a strong story — particularly given that these are open-weight models:
Ornith 397B MoE (Flagship)
- Outperforms Qwen 3.7 Max and the MiniMax model on coding benchmarks
- Competitive with Claude Opus models on agentic coding tasks
- Sets a new bar for what open-weight models can achieve in coding
Ornith 35B MoE
- Performs very well against models of similar size
- MoE architecture means lower active parameters during inference
Ornith 9B
- The standout for local deployment — outperforms models 3× its size on coding tasks
- Ideal for developers who can't run 35B+ models locally
6 Historical Context — The PAL Paper
Sam contextualizes Ornith's approach by referencing the PAL (Program-Aided Language models) paper from late 2022 (published January 2023). PAL proposed a then-novel idea: instead of having the model do math in its head, why not have it write Python code to solve the problem, execute that code, and bring the result back?
The concept of models writing code they then use is nearly four years old. But Ornith takes this dramatically further — from writing a simple math function to writing an entire agent scaffold. This leap reflects both how much more capable models have become and the direction the field is heading: as models grow more intelligent, the goal is to minimize human involvement in designing the systems around them.
7 Demo: SVG Drawing & RAG Tasks
Sam demonstrates the Ornith 35B MoE (quantized, running via llama.cpp) on a Dell Pro Max with an RTX 6000 Pro GPU. The first tests are straightforward capability checks:
Pelican SVG Test
The classic "draw a pelican" SVG test produces a high-quality result right away. This is somewhat expected given the strong Qwen 3.5 base, but confirms the fine-tuning hasn't degraded general capability.
RAG Question Answering
Given a RAG-style question, the model generates extensive reasoning/thinking tokens, works through the relevant context, and produces accurate answers — without needing to write any code. It correctly identifies this as a task that doesn't need a harness and proceeds directly to reasoning.
This demonstrates an important quality: Ornith doesn't reflexively generate scaffolding for every task. It has learned when scaffolding is necessary and when direct reasoning suffices.
8 Demo: Weather Harness Generation
The real showcase of Ornith's self-scaffolding ability starts with: "Create a harness to get the weather with a 5-day forecast."
First Attempt: With API Key
The model's chain-of-thought process is revealing — it first understands the goal of creating a harness (not just answering a question), then designs a solution with ~1,600 thinking tokens. The resulting harness:
- Imports the
requestslibrary - Creates a structured
WeatherHarnessclass for 5-day forecasts - Includes graphical display logic
- Requires an OpenWeather API key (a reasonable default)
Second Attempt: No API Keys Allowed
When Sam adds the constraint "we don't have any API keys", the model adapts beautifully:
- The thinking tokens explicitly note: "implicit need — find a free, no-API-required weather source"
- It discovers and uses the Open-Meteo API (genuinely free, no signup needed)
- Rewrites the entire harness to match the new API, including weather code-to-emoji mappings
- Uses GPS coordinates instead of city names (matching Open-Meteo's interface)
9 Demo: Twitter AI News Harness
The next demo pushes harder: "Create a harness to get the latest AI news from Twitter."
With API Access
The model generates a harness using Twitter's official API, correctly understanding the API's authentication requirements and data structures.
Without API Keys
When told there are no API keys available, the chain-of-thought becomes more structured and deliberate:
- Understand user request — parses the exact goal
- Identify constraints — no API keys allowed
- Identify key challenges — Twitter's anti-scraping protections
- Explore alternative approaches — considers multiple strategies
After ~3,200 thinking tokens, it produces a scraping-based solution with a curated list of AI-focused accounts to follow. Sam notes the scraping approach would likely get blocked quickly, but the logic and structure of the harness are sound.
Multi-Turn & Gradio Integration
In a chat-mode test, after the model generates the initial harness, Sam asks: "Can you build a Gradio interface?" The model responds with minimal thinking tokens — it recognizes the harness already exists and only needs to add the UI layer, avoiding redundant re-generation of the Twitter logic. It produces a clean Gradio app quickly.
10 Practical Considerations
Sam shares his honest assessment of where Ornith fits in the current coding model landscape:
- Not a daily workhorse replacement — for daily coding tasks, proprietary models like Claude Code and Codex still have the edge in Sam's workflow
- Excellent for local coding — if you need to run models locally (privacy, cost, offline access), the 9B and 35B MoE are strong choices
- GPU-constrained developers — the 9B model specifically is recommended for those without big GPUs, outperforming much larger models
- Quantized deployment works — Sam ran the 35B MoE quantized through llama.cpp and still got impressive results, including fast inference on the RTX 6000 Pro
- One-shot vs. iterative — all demos were single-shot. Setting up iterative loops (passing results back in, auto-executing code) would likely improve results further
The self-scaffolding paradigm is conceptually powerful beyond agentic coding, though Sam notes the current challenge is that reward signals need to be measurable/verifiable via GRPO — making coding a natural first domain.
🎯 Key Takeaways
🔑 Key Takeaways
- Self-scaffolding is the core innovation — Ornith models learn to write their own agent harnesses, treating scaffolding as a learnable object rather than a human-designed fixture
- Four open-weight models — 9B, 31B, 35B MoE, and 397B MoE, all fully released with no held-back flagship
- Joint optimization via GRPO — a two-stage RL loop simultaneously improves the model's ability to generate scaffolds and produce solutions within them
- Three-layer reward hacking defense — immutable environment, deterministic monitor, and LLM-as-judge veto prevent the model from gaming its own training
- 9B model punches way above its weight — outperforms coding models 3× its size, ideal for GPU-constrained local deployment
- 397B MoE competes with Claude Opus — the flagship model sets a new bar for open-weight coding performance
- Adaptive constraint handling — the model adapts its scaffolding to constraints (e.g., switching from OpenWeather API to Open-Meteo when told "no API keys")
- Smart task routing — Ornith doesn't generate scaffolding for every task; it knows when direct reasoning suffices (e.g., RAG questions)
- Multi-turn efficiency — in chat mode, the model avoids re-generating existing harnesses when extending with new features
- PAL lineage — the concept traces back to PAL (2022), but the jump from "write a math function" to "write an entire agent scaffold" represents a massive capability leap
🔗 Resources & Links
- Ornith 1.0 Blog Post — official Deep Reinforce blog with full technical details and methodology
- Ornith 1.0 on Hugging Face — all four model weights (9B, 31B, 35B MoE, 397B MoE)