Ornith-1.5: From Self-Scaffolding to Self-Improvement

Published August 2026 | Ornith Blog

We are thrilled to unveil Ornith-1.5, a pivotal advancement in our journey toward creating foundation models capable of end-to-end self-improvement.

While Ornith-1.0 introduced the concept of self-scaffolding, version 1.5 evolves this into a comprehensive, autonomous loop. The model now doesn't just follow a scaffold; it proposes its own tasks, engineers the necessary scaffolds, and executes solution rollouts for reinforcement learning (RL). This creates a perpetual engine of growth where the model generates its own learning experiences.

---

🚀 Model Architecture & Scale

Ornith-1.5 is available in three distinct configurations to balance raw power with deployment flexibility:

Note: The Ornith-1.5-9B-Mobile quantized version allows for seamless integration on Android and iOS devices without sacrificing significant intelligence.

---

📊 Performance Benchmarks

Ornith-1.5 is engineered for excellence in coding, agentic behavior, and complex reasoning. It consistently matches or beats the most capable models currently available.

Flagship Scale (397B)

The 397B MoE model is a powerhouse, performing on par with proprietary giants:

• Terminal-Bench 2.1: 86.1 (Matches Claude Opus 4.8's 85.0)
• DeepSWE: 56.0 (Comparable to Claude Opus 4.8's 59.0)
• Comparison: It significantly outperforms other open-weights models like GLM-5.2 (82.7 / 46.2) and DeepSeek-V4-Flash-0731 (82.7 / 54.4).

Mid-Range & Edge Scale

• Ornith-1.5-35B: Despite only activating 3B parameters per token, it crushes dense models like Gemma 4-31B and Muse Glimmer-30B in agentic coding (scoring 68.5).
• Ornith-1.5-9B: This compact model achieves a surprising 47.0 on Terminal-Bench 2.1 and 70.6 on SWE-Bench Verified, beating the 31B and 35B versions of Gemma and Qwen respectively.

---

⚙️ The Self-Improvement Mechanism

Ornith-1.5 moves away from static, human-curated datasets. Instead, it employs a joint optimization of task generation, scaffold construction, and solution execution.

The Workflow Loop

1. Task Proposal: Using previous history and environment data, the model suggests tasks that are progressively more difficult to expose its own weaknesses.
2. Scaffold Construction: The model creates a scaffold—a blueprint containing:
   • Specific instructions.
   • Tool selections.
   • Decomposition strategies.
   • Orchestration logic.
3. Solution Rollout: The policy executes the task based on the scaffold.
4. RL Propagation: Rewards are fed back into all three stages, teaching the model to not only solve problems but to design better problems and better ways to solve them.

---

🧮 Mathematical Framework for Task Reward

To ensure the model doesn't "cheat" or stagnate, we utilize a specific reward function for the question $\rightarrow$ scaffold $\rightarrow$ rollout pipeline.

Let $q$ be the generated question, $s$ the scaffold, and $\{\tau_i\}_{i=1}^{N}$ the set of solution rollouts. The task reward is defined as:

$R_{\text{task}} = \underbrace{V(q,s)}_{\text{Validity}} \times \underbrace{D\!\left(q,s,\{\tau_i\}_{i=1}^{N}\right)}_{\text{Frontier Difficulty}} \times \underbrace{N(q)}_{\text{Novelty}}$

Reward Component Breakdown

• Validity ($V$): Is the task coherent? Does the scaffold execute and evaluate correctly?
• Frontier Difficulty ($D$): Is the task neither too easy nor impossible?
• Novelty ($N$): Is this task different from what the model has already seen?

1. Validity and Verifiability

A task is only useful if it is verifiable. We define $V(q,s) \in [0,1]$. If a scaffold fails to run or cannot distinguish between a correct and incorrect answer, it is treated as a hard gate: if V(q,s) == 0 then R_task = 0

2. Frontier Difficulty

The most effective learning happens at the "edge" of capability. We calculate the empirical success rate $p$ across $N$ rollouts:

$p = \frac{1}{N} \sum_{i=1}^{N} \mathbf{1}\!\left[s(q,\tau_i)=\text{success}\right]$

Tasks where $p$ is near 0.5 are typically the most informative for reinforcement learning.

---

🖼️ Conceptual Overview

Figure 1: The transition from static training to a dynamic, self-evolving curriculum.

Implementation Example (Pseudo-code)

def self_improvement_step(model, env):
    # 1. Propose a new challenge
    question, scaffold = model.generate_task(env, history=model.memory)
    
    # 2. Execute multiple attempts
    rollouts = [model.solve(question, scaffold) for _ in range(N)]
    
    # 3. Calculate the multi-factor reward
    reward = calculate_reward(
        validity=check_v(question, scaffold),
        difficulty=calculate_p(rollouts),
        novelty=check_n(question, model.dataset)
    )
    
    # 4. Update policy via RL
    model.update_policy(reward, rollouts)