Two months of madness 11%, coding self-defense against Opus 4.8

  It's the first time in the history of the world.

To train a model that works, the most expensive is not a graphics card, but a training task.

When it comes to coding and intelligent objects in particular, it is not enough to have a theme and an answer: it is necessary to prepare a running environment, a test that is judged to be incorrect, and to prevent the replication of the model.

The difficulty can't be ignored.

It's too simple, the model is done with its eyes closed, and nothing has been learned; it's too difficult, it won't happen, and it's the same as burning a round of calculus.

These are all packed, and there's plenty to eat.

In the past, this has always been done by people. Slowly, not to mention, mainly because of the lack of supply: you just put together a batch and the model turns around and it's done.

So what if the model asked herself a question?

Someone really did it.

In August of this year, Ornith released 397B MoE, 35B MoE and 9B Dense in three weight classes.

There is an unprecedented link in the training process: the model itself generates the training task, the problem solves itself, runs its own problem solving trajectory, and throws three sections together into reinforcement learning.

The theme of this story is that AI has gone from man to man.

The numbers paid off immediately.

On Terminal-Bench 2.1, 1.0 was 77.5 two months ago, and this time the 397B ran to 86.1.

In the same table, Ornith gave Claude Opus 4.8 a score of 85.0.

An MIT weight that can be downloaded at any time is in front of the closed-source flag in this table.

Ornith 1.0 in June has done something quite radical: turn an agent script shelf, a desktop for solving AI problems, into a learning object.

It is common practice for human engineers to design a script for a specific type of task: how to give a tool, how to dismantle a task, how to retest it, how to write it down, and then have the model repeatedly printed in this fixed framework.

1.0 dismantled the framework and handed it over to the model itself.

Each step of reinforcement learning is divided into two sections: first based on the task and a new version of the shelf used in the previous round; then on this version of the shelf to run the puzzle trajectory.

Ornith-1.0 is a two-step self-improvement framework. First, the script is changed, then the puzzle track is run, and the two-step feedback is rewarded.

The model has learned how to build a desktop. But it's still human: where did the theme come from, 1.0 didn't touch.

1.5 This circle has also passed.

Given a code library, a high-level explanation of the type of task, and the model's own past solving records, Mr. System created a new set of problems that were more difficult to solve than it had already done.

The model then generates or improves an exclusive scripting framework for the theme: instructions, tools, dismantling strategies, compilation logic.

Finally, under the dual conditions of mission and footrest, run out of the trajectory.

The rewards are transmitted backwards from the trajectory of all three segments, together with GRPO optimization.

The key is that the half of the volume is also split. The title is not good, the other half of the title is also split.

The theme, the stage, the solution, the circle is closed at this moment.

The stronger the strategy, the more difficult the puzzles, the more information is available; the more the scaffold evolves, the more it can reveal the reality of the model; the trajectory increases in quality and, in turn, produces more sophisticated learning signals.

In the last two years, the open model has been catching up with the closed-source flag in two main ways: stacking parameters and copying.

Ornith didn't want to copy it. He wanted the AI to copy it himself.

Sounds great, but you can quickly come up with a puzzle: what if the model gives itself a quiz?

Where the rewards go high, the model goes wherever it goes. A person who only comes up with the "1+1 equals how many" questions can blow up the scores, but there is no training signal.

Ornith's method is to break down task rewards into three signals: effectiveness, front-end difficulty, novelty, and multiplication of the three.

Multiplication is key. Any number that is close to zero is rewarded with zero. To score, all three must be formed at the same time.

The question of effectiveness is not valid:

The rack does not run up, the correct solution of high confidence cannot be passed, the obviously incorrect solution will not be condemned as a failure, and the logical and task description will not be correct.

The team simply took it as a hard barrier, not qualifying directly to zero, to block those who look hard, in fact, can't judge the wrong questions.

The front-end difficulty is a highlight of the overall design.

The system sampled several tracks for each question and calculated the success rate of the experience, the closer to the target value of 0.2, the higher the reward.

That is to say, a good question, the model should be done twice in ten times.

If it is done eight times, it means that it has already been done, without any training value; if it is not done once, even a successful path to energy education cannot emerge, reinforcement learning is equally empty.

The curve must be stepped on the model's very bad position.

What's even more interesting is that it moves with the model's ability: a certain type of problem is mastered, the success rate goes up, the reward goes down automatically, and the end of the problem can only continue to code.

Neonatal is the third lowest weight and is only responsible for one thing: not getting old with variations of the same theme.

The official specification notes that its priority is lower than the first two, and its duty is to be redundant and not rewarding.

So this set of "self-improvement" really improves the automatic evolution of the curriculum.

The whole process takes place during the training phase.

The weight you drop from the Hugging Face is dead, and it won't work on your laptop or phone and change itself.

Let's talk about how 86.1 came about.

This Terminal-Bench 2.1 score, which was run by the Ornith team in their own environments using their own configuration, is written as an average of five independent runs.

Terminal-Bench 2.1 itself has an official verification list, each of which is uploaded by a member of the list team after the verification process.

As of August 19, 2026, there are 17 entries on the list, none of which include Ornith-1.5.

Terminal-Bench 2.1 is in the top eight of the official list. Opus 4.8 has no Ornith-1.5 in 5th, 17th and 78.9% respectively.

More importantly, the opposite objects.

On the Ornith chart, Opus 4.8 has a rating of 85.0, which is the number of times they have run Opus 4.8 on their own Terminus-2 framework. On the official list, Claude Code plus Opus 4.8, submitted by Anthropic, has a rating of 78.9%, ranking 5th; the highest ranking is 83.8% of Claude Code plus Fable 5.

The same Opus 4.8, the two tables differ by 6.1 points.

The difference is who is measuring, what is being measured.

Terminal-Bench is a benchmark for smart entities that measures the combined performance of models, scales, overtime, context, and resource allocation.

In a different configuration, the score changes its meaning.

Therefore, a submission rule is posted on the list page: no overtime or resource allocation can be modified.

Ornith's blog reveals a self-configuration of 4 hours of super-time, 32 CPUs, and 48GB of memory.

Additionally, configurations have been moved, including official deadline and resources.

These changes are not necessarily driven by separation, but the comparable premise is gone: project self-assessment and official verification lists cannot be placed in the same ranking.

This level of license should also be clearly stated.

The public GitHub repository currently consists mainly of README, LICENSE and demonstration materials, and has not seen 1.5 complete training implementations, training task sets, or replicable assessment scripts.

Open weight is not equal to the whole open source set.

The flagship is responsible for hot searches, and small to medium sized vessels determine how many people can actually use it.

In this release, the two most easily overlooked are the ones in the middle.

35B-A3B is a MoE, with each token activating only about 3B parameters.

With this activation, Terminal-Bench 2.1 ran to 67.8, up from 42.1 on the Gemma 4-31B and 51.7 on the Muse Glimmer-30B.

3B activates the winning 31B compact model, one of the most cost-effective in this release.

The smaller one, the 9B Dense, is the one that shows off the edge.

Terminal-Bench 46.2, SWE-bench Verified 70.6, GPQA Diamond 86.4 are self-tested.

On Hugging Face, a 5.63GB compressed version has been released, as well as the MX format for Apple computers.

However, the 9B has not completely overwhelmed the Gemma 4-31B.

It did lead in coding and reasoning, with MCP-Atlas at 54.2 to 55.0, and Toolathlon-Verified at 41.2 to 52.8.

The two tests were multi-cycle tuning tools, retrieval of results, state-by-state scheduling, chain length, and 9B capacity.

Coding and reasoning can be trained to compensate for weight loss, and tools call for compensation.

Terminal-Bench self-tested 77.5 as of June 1.0, 1.5, 86.1 as of August.

Over the past two months, it has risen by about 11.1 percent.

What's more important than this number is how the capabilities behind it evolved.

1.0 is learning "how to solve" and 1.5 is beginning to learn "what to practice". This process of data production has been moved into the whole enclosure of reinforcement learning.

High-quality intelligent body training has always been a rarity.

The speed at which man-made systems are organized does not match the speed at which models can solve problems. This is a very specific engineering problem.

The way the open model tracks the closed-source flag is changing.

In addition to stacking the parameters and copying the formula, there is another way: to create your own problems.

Ornith-1.5 has three closed-loop sections: generate tasks, generate scripts, run off tracks, reward relay three sections, unified with GRPO updates.

The upper limit of the model is that in addition to spelling, there is also a spelling library.

It's just that when the questions, the stages, the solutions are given to the model, what is the position of humans in this closed loop?