Video summary

Introducing Ornith 1.0 - Agentic Coding LLMs

Main summary

Key takeaways

Technology

Ornith 1.0: Agentic coding LLMs with “self-scaffolding”

Ornith 1.0 is presented as a new family of agentic coding LLMs from Deep Reinforce. Its goal is to remove a major bottleneck in agentic coding systems: humans manually designing the “harness”—the scaffolding/tools/instructions an agent uses to execute a task.

Instead, Ornith trains models to:

  • write their own task-specific harnesses on the fly, and
  • use those harnesses to produce solutions.

Core idea: Learnable “self-scaffolding” / harnesses

In typical systems, harnesses are hand-designed. Ornith changes the framing: treat the harness as a learnable object, so the model also learns how to build better scaffolds (automatic context engineering) rather than relying on manual setup.

The model jointly optimizes:

  1. the agentic trajectory (rollout) used to reach the goal, and
  2. the task-specific harness that guides that rollout.

Model lineup & availability

The video describes 4 models, derived from Qwen 3.5 and Gemma 4 families via fine-tuning / mid-training / post-training (i.e., not brand-new pre-trains):

  • 9B (Qwen 3.5)
  • 31B (Gemma 4 family)
  • 35B MoE (Qwen 3.5)
  • 397B MoE (Qwen 3.5)

A notable product feature: all models are released (including the largest), rather than only exposing top models.

Reported performance (benchmarks)

The biggest model is claimed to:

  • outperform multiple competitors (including Qwen 3.7 Max / mini max variants), and
  • be competitive with Claude Opus in many cases.

Smaller models are also reported to do well relative to their size (e.g., the 9B allegedly competes with models several times larger). The narrator also highlights the 9B as appealing for local/off-GPU-constrained coding.

Training approach: two-stage IRL + GRPO

A central technical mechanism described is a two-stage IRL-style process with GRPO.

Given:

  • a proposed task, and
  • a previous scaffold/harness for that task,

Ornith proceeds as follows:

  • Stage 1: the model refines/generates a new harness.
  • Stage 2: conditioned on that harness, the model generates the rollout/solution trajectory.

Multiple rollouts produce outcomes used as reward signals, and training updates both:

  • harness generation quality, and
  • rollout generation quality.

The video claims the reward optimization uses GRPO. The narrator emphasizes that making this reliable—without collapse or failure—is the project’s main challenge.

Defending against “reward hacking” (cheating harnesses)

Because harness generation could learn shortcuts that “game” the verifier/judge, the video describes three layers of defenses:

  1. Immutable environment/tools/sandbox

    • The harness can’t change the execution environment to exploit loopholes.

  2. Deterministic monitoring

    • A monitor checks harness behavior for disallowed actions (e.g., modifying verification scripts, using unsanctioned tools, escaping the sandbox) and penalizes violations.

  3. LM-as-a-judge veto

    • Even if early checks pass and GRPO reward is high, an additional judge can veto outcomes achieved via unacceptable methods.

Practical demonstration (tutorial-style testing)

The narrator runs Ornith 1.0 (primarily the 35B MoE) in a local test suite and shows examples:

  • SVG drawing (“Draw pelican”)

    • Produces a decent SVG with strong immediate results.

  • RAG-style question

    • Produces useful answers and notably doesn’t rely on writing code in that case.

  • Harness generation: weather forecast

    • Prompt: create a harness for a 5-day forecast.
    • The model:
      • drafts a substantial script (example mentioned ~1600 tokens),
      • suggests using an API key if available,
      • adapts when told no API keys:
        • searches for alternatives,
        • switches to Open-Meteo (described as no signup required),
        • rewrites the script accordingly (including interpretation logic like converting codes to emojis/descriptions).

  • Harness generation: latest AI news from Twitter

    • Prompt: get latest AI news from Twitter.
    • With API keys: it generates code targeting the Twitter API.
    • Without API keys: it attempts a workaround (e.g., scraping by following accounts). The narrator notes success may be limited due to blocking, but the strategy shift is presented as reasonable.

  • UI output integration

    • The model can generate a Gradio interface:
      • after generating the underlying harness, it structures the UI plan quickly and renders a Gradio app.

Overall takeaway

The reviewer/narrator considers Ornith 1.0 worth trying, recommending:

  • 35B MoE for capability, and
  • 9B for local use when large GPUs aren’t available.

They don’t claim it will fully replace daily coding workflows, but suggest it could be a valuable option for local agentic coding.

Main speakers / sources

  • Speaker: the YouTube narrator/reviewer (no name provided in the subtitles)
  • Project/source: Deep Reinforce (developer of Ornith 1.0)
  • Technical reference mentioned: the PAL paper (used as background on tool/code generation concepts)

Original video