Two pieces of news pointed in opposite directions this July.

One was the official announcement of Kimi K3: 2.8 trillion total parameters, the largest open model out there, beating Claude Fable 5 and GPT-5.6 Sol on some coding benchmarks (while Moonshot themselves frankly admit it still trails both overall). Make the model bigger, buy more performance. The straightforward direction.

The other went the opposite way. Schema, a reasoning harness, reports solving 98.98% of the ARC-AGI-3 public set with a combination of Claude Opus 4.8 and Fable 5. It doesn’t touch the model weights at all. What it changes is the scaffolding around the model: how observations become a world model, how predictions get tested, and where to start fixing things when they miss. On the same public set, GPT-5.6 Sol alone scores 13.33%; put Schema around it and it reaches 95.35%. Same model, over 7x the score, from outside design alone. And these are the same models I use every day.

The caveat first: that 98.98% is self-reported and has not been verified by ARC Prize. The page itself says so in a figure caption. So I’m not treating the number as established fact. I’m bringing it up anyway because the direction, wildly different scale aside, matches what’s been happening on my own machine.

ARC-AGI-3 is a world that grades your answers

In ARC-AGI-3, an agent gets a 64×64 grid of 16 colors and a list of legal actions. No rules, no stated goal. The only way forward is to form a hypothesis, act, and check the hypothesis against the screen that comes back. That 13.33% above is a single model’s score on this public set. On the Semi-private set, where scores get verified, the numbers drop further: 0.51% at the March launch, 7.78% with GPT-5.6 Sol in July. Rising, not plateaued, but on either yardstick a bare model doesn’t come anywhere near the human baseline of 100%.

Schema describes its own approach as thinking like a physicist. The definition of state (which pixels are the “player”, which are a “wall”) and the rules for how actions change that state live in one editable program. When a prediction misses, you either fix the rule or question the state definition itself.

Clever setup. But what matters more, I think, is the precondition that makes it work. The game environment always answers back. If your hypothesis is wrong, the next screen tells you so. Grading is mechanical and repeatable, as many times as you need. The harness’s job is to wire the model into that grading loop correctly.

Putting my own three measurements on the same line

I’ve measured “buying performance with outside design” three times myself, at a much smaller scale.

In one post I split the work: Fable 5 wrote the spec, Sonnet 5 wrote the implementation. Separating the judgment-heavy stage from the volume stage let an adversarial review kill three High findings before any code existed. Implementation correctness had 189 tests as its safety net, so a machine did the grading. What I bought: a process with zero rework. What I couldn’t buy: knowing which layer the safety valve would actually fire in. That only became clear when I ran it against real URLs.

Another post measured the side you can’t buy. I distilled 11 review findings from a top-tier model into 4 permanent rules, wrote them into my process docs, and measured how much they helped on the next post: 8 findings. Exactly 1 was something the rules could catch mechanically; the other 7 were reading work. Is the claim actually resolved by the end? Do the table and the prose contradict each other? The only defects I could transfer into the harness were the kind you can count with grep.

In the third, an audit running 4 agents in parallel found two silent-bypass holes in hooks I had written myself. Whether a command slips through is decided by a 20-case matrix of ASK vs SILENT, so this was a win for the buyable side. I also measured the price: two review passes on one blog post ate close to 170,000 tokens and just under 9 minutes. Buyable performance comes with a price tag.

The line runs along “can a machine do the grading”

Line up the three with Schema and the line sits in the same place every time.

What the harness buys is the territory where grading can be mechanized. The game environment scores your hypothesis with the next screen. The tests tell you whether all 189 pass. Hook bypasses show up when you run the 20 cases. A table row with no matching prose can be counted by a machine. Here, with the model unchanged, outside design multiplies performance. If Schema’s 99% is real, my read is that it’s because ARC-AGI-3 is a grader’s paradise: every action gets an answer back.

What it doesn’t buy is the territory where no grader exists. Is the post’s claim resolved in the closing? Is the safety valve in the right place in the spec? There is no equivalent of “run it and a screen comes back”. Back when I wrote about those 7 findings, I framed them as “couldn’t be turned into rules”. Restated along this line: it’s not that they can’t be turned into rules, it’s that there’s no grader. The problem sits below rule quality, at the level of the environment. So for that stage, and that stage only, I keep paying a top-tier model to do the reading.

The lineup

Closing

Making the model bigger is the 2.8-trillion-parameter direction; designing what surrounds the model is Schema’s direction. But before getting drunk on that 99%, my own measurements sober me up. A harness only buys performance where grading can be handed to a machine: where tests can be written, where an environment answers back, where grep can count. In those places, keep the model and buy the design. The most expensive thing on my desk is the reading stage, where no grader exists, and no amount of harness has made it cheaper. The buyable side isn’t free either; it comes with price tags like those 170,000 tokens. But that’s a tag you can simply pay. The unbuyable side won’t sell no matter how much harness you stack. Buy with design where you can, pay for reading where you can’t. Knowing where that line runs is the saving that comes before model choice.