Hunting the Fable Destroyer: can open weights replace a banned frontier model?

On June 12, 2026, Fable 5 disappeared. An export-control directive covering foreign nationals landed, the provider disabled access for every customer to comply, and a lot of products that had quietly wired themselves to a single frontier model woke up to 100% error rates.

The day after, OpenRouter put out a claim that you could "approach its capabilities" with what's already on their platform. That's a marketing sentence. This post is me trying to turn it into a number.

The question I actually care about: if you can't get the best closed model anymore, how close do open weights get on real agentic coding, and what does it cost? And the more interesting version: can a mix of cheap open models (one that plans, one that implements, one that reviews) beat any single open model? I started calling whatever wins "the Fable destroyer."

The setup: one agent, one rubric, two venues

I run a little benchmark called lemon-squeezer. It started as a way to figure out which local models are actually usable as coding agents on a single RTX 4070. The trick that makes it honest is that everything goes through one tiny agent, about 250 dependency-free lines of a tool-calling loop with four tools: read_file, write_file, list_files, run_bash. Point it at local Ollama or at any OpenAI-compatible cloud endpoint; the only thing that changes is the base URL and the model name.

Each task (an "eval") is just two files: a prompt.md describing the work, and a rubric.sh that runs the produced code and prints a score. Rubrics grade runtime correctness, not vibes. A program that looks right but returns the wrong answer on real input loses most of its points. The suite spans algorithms (Dijkstra, Huffman, a regex engine), systems (rate limiter, LRU cache), numerics (Kalman filter, FFT), and bug-fixing.

So I added a cloud twin of the runner and pointed the exact same agent at OpenRouter. Same prompts, same rubrics, different venue. Now "open model in the cloud vs. my 4070" and "model A vs. model B" are honest, apples-to-apples comparisons.

The contenders

Single models, a price ladder of open weights, cheapest to frontier-open:

Mixes, the actual hypothesis. A mix wires several models in sequence over one shared workspace:

• architect: an expensive model writes the plan, a cheap model implements it. Expensive brain, cheap hands.
• critique: a cheap model drafts, a frontier model reviews, the cheap model fixes. Draft → critique → refine.
• ensemble: three different cheap models each take a crack, a frontier model judges and promotes the best. Diversity + a smart referee.
• verify: one model writes the code and property-based tests for it, then iterates until the tests pass. Self-checking.

The idea behind every mix is the same bet: most of the work in a coding task is boring, and you only need the expensive model for the 20% that's actually hard. If that bet pays off, a mix should land near a frontier model's score for a fraction of its cost.

Method

Everything runs through one driver that fans every arm across the whole suite, several trials each, in parallel, with a single writer to the results file and a hard dollar budget cap. It's ordered so that if the budget runs out mid-sweep, you still have a complete cross-arm comparison on a prefix of the suite, the cleanest possible partial result. The whole experiment lives in version control as a config file, so it's reproducible: clone, set a key, run one command.

(One detail I'll spare you in full: getting bash-based rubrics, CRLF line endings, and :-illegal filenames to all behave on a Windows box took longer than the actual modeling. Open weights are easy; git on Windows is hard.)

Results

751 runs, $9.89, zero errors. Here's the top of the board (full table and a live, auto-updating version on the dashboard):

Three things jump out.

The Fable destroyer is a single cheap model. deepseek-v4-flash was the only arm to score 100% on all 16 evals, at about a fifth of a cent per task. The whole frontier-open tier (deepseek-v4-pro, kimi, glm-5.1, qwen3-max) lands at 98 to 100%. On this suite, the gap between "the best model money could buy last week" and "an open model you can rent today" is, functionally, gone.

The best value is gpt-oss-120b: 95% for half a thousandth of a dollar per task. If you're running at scale and can tolerate the occasional miss on a genuinely hard algorithm, nothing else is close on cost.

The mixes mostly lost. This is the part I got wrong going in. I expected a clever ensemble or a plan-then-implement pipeline to be the destroyer. Instead, no mix beat the best single model, and the heavy ones (three models drafting with a frontier judge, or draft→critique→refine) cost 5 to 25× more and ran 3 to 5× slower for lower scores than just calling deepseek-v4-flash once.

What it means

Mixes aren't useless. They're just not a quality ceiling raiser. They're a weak-model rescue kit. Watch what they do to qwen3-coder-30b, which scores a sad 69% on its own:

A critic loop drags a 69% model up to 94%. Self-verification gets most of the way there for a tenth of the cost. So the rule of thumb is:

• A strong cheap single model exists? Just use it. (It does: deepseek-v4-flash, or gpt-oss-120b for pure value.)
• Stuck with a weak/tiny model (local, on-device, privacy-bound, whatever), wrap it in self-verification or a critic and reclaim 20+ points.
• Want a near-perfect score from a cheap model cheaply? A one-shot architect plan is the only mix that paid for itself: a qwen-max plan lifted gpt-oss-120b from 95% to 99.5% for a third of a cent.

Where did the field actually separate? Not on the easy stuff. Almost everyone aces dijkstra and base64. It was a handful of dense tasks: a regex engine, matrix ops, an FFT, a Kalman filter. That's where the cheap small models score 0 to 75% and the good models hold 100%. The "intelligence" you're paying for is narrow and specific.

And the local angle, because it's the whole reason I built this: my RTX 4070, with the right harness, hit 97% on these tasks (gpt-oss:20b through aider). A free GPU you own gets you to 97; a fraction of a cent in the cloud buys the last three points and the 480B models that won't fit in 12 GB of VRAM. Neither one requires a frontier lab's permission to keep working.

The lesson

The models will keep getting banned, deprecated, repriced, and rate-limited. The thing that survived this particular outage wasn't a model. It was the harness: a thin, model-agnostic agent and a rubric that tells the truth. Build the part that doesn't change, and swapping the model underneath becomes a one-line diff instead of a fire drill.

Reproduce it: github.com/noahjohnson0/lemon-squeezer. bin/cloud-matrix runs the whole thing.