Fable 5.1: Cheap Tokens, and the Harness Nobody’s Watching

An episode of Dan's AI Intel

Anthropic’s dearest model got better — but the thing that actually changed how it works was the harness, not the weights. Cheap tokens still aren’t cheap work.

Published · By Dan Walter

Executive summary

Anthropic's newest coding model, Fable 5.1, is a genuine step up — and the number everyone will quote about it is the wrong one. The mythos class it belongs to really did move: on the agentic, terminal-style evals that decide real engineering work, Fable 5.1 roughly doubles its own predecessor on the hardest tasks and now edges out Opus 5, the model most engineers reach for by default. It is also, per token, the single most expensive model on the frontier board — ten dollars per million tokens in, fifty out. So its entire value rests on a number nobody has actually measured for it yet: not what a token costs, but what a finished task costs.

But the more important story this summer is not about a model at all. It is about the scaffolding wrapped around it — the harness. In late July, an Anthropic engineer stood up at a developer conference and admitted the company had deleted more than eighty per cent of Claude Code's system prompt for its newest models and lost nothing on the evals. The instructions written to make the tool reliable had, in many cases, been making it worse. That single fact reframes everything: the same model weights can go from thrashing to excellent purely because someone changed the words around them. Which means the popular read that "Anthropic needs a win" after a rough Opus 5 launch is only half right. The win is real — but it is as much a harness win as a model win, and the two are constantly being confused.

The verdict is calibrated optimism, held honestly. Fable 5.1 is a careful, well-adjusted release from a model class that spent months behind safety gates rather than sitting stale. Its benchmark gains are real and its early hands-on reports are strong. But whether it is actually cheap to work with is unproven, and much of the excitement about how it "feels" may be crediting the model for a harness fix that arrived weeks earlier. Treat the scores as settled, the cost-per-task story as open, and the feeling as a hypothesis to test against your own work.

The most expensive token on the board

Exhibit — Fable 5.1 is the most expensive token on the frontier board. Per token, nothing on the board is dearer — so the only way it is "cheap" is per finished task. Source: Anthropic pricing; Morph fleet price tables; vendor pages. Input is $10/M. As of 1 Sep 2026.

Frontier model launches have become routine enough to tune out, which is exactly why they reward attention. Each one is a live readout on where the whole race actually sits — not where the marketing says it does. And the gap between those two things is the recurring argument of this show: we have watched a top-of-the-table model turn out to be nearly unusable in daily work, and a "cheaper" model quietly cost more once you counted the whole job. Fable 5.1 is a good test case because it is loud on the benchmarks and strange on the price sheet at the same time.

Start with the strange part. Fable 5.1 lists at ten dollars per million input tokens and fifty per million output — unchanged from Fable 5, and the highest sticker on the board. Output is the number that dominates a reasoning model's bill, because the model is billed for every hidden "thinking" token at the output rate, and those can outnumber the visible answer many times over.

Anthropic knows how that looks and argues the point directly. Set to low or medium effort, they say, Fable 5.1 matches Fable 5's quality at lower cost, and typical workloads run about twenty-five per cent cheaper than before — agentic ones up to roughly forty-five per cent cheaper. It also cut cache reads by seventy-five per cent. Notice what all of those claims are really about. Not the token price, which did not move. They are about how much work the model gets done per token — a different axis entirely, and the one that actually matters.

Cheap tokens are not cheap work

Exhibit — Which models turn tokens into finished work — and which waste them. The cheapest token is not the cheapest work — a model that fails more burns more to finish the same task. Source: MODELED, illustrative: task cost = output price × ~55K output-billed tokens/task (sourced midpoint) ÷ solve rate; Fable 5.1 solve is an early proxy. Not a billed measurement. Baseline = median finished tasks per million output tokens across the fleet. Benchmark: SWE-bench Verified. As of Sep 2026. Burn held constant across the fleet, so this is solve-rate-adjusted price efficiency, not measured token burn.
Exhibit — Finished tasks per million output tokens — the cheapest token buys the least. Dividing task-cost by token-price strips the sticker away and leaves pure efficiency — and the ranking inverts. Source: Finished tasks per million output tokens = solve rate ÷ tokens per attempt. Bars carry each lab's own brand colour. Benchmark: SWE-bench Verified. As of Sep 2026.

That different axis is the whole point. Cost per task is what it takes to finish a real unit of work — solve a bug, complete an agent loop — and it folds together three things: the price per token, how many tokens the model burns thrashing toward the answer, and how often it finishes at all. A model that is cheap per token but flails, retries, and burns five times the tokens can be the more expensive choice once the job is actually done. Cheap tokens are not cheap work — the same paradox we unpicked when a cheaper Sonnet 5 somehow cost more, in episode 24: the sticker fell, the bill rose, because the model did more per task.

Plot the frontier fleet on those two axes and the rankings visibly diverge. The catch is that clean, independent cost-per-task numbers barely exist yet — and for Fable 5.1 specifically they do not exist at all. So the matrix below is modeled, not measured: it estimates each model's cost to solve a standard coding task from its output price, a sourced midpoint of roughly fifty-five thousand billed tokens per task, and its solve rate. Treat it as a shape, not a scoreboard.

Two quadrants tell the story. The bottom-left is the prize — cheap per token and cheap per task — where workhorses like Sonnet 5 and Haiku 4.5 live; Sonnet 5 resolves roughly three in four standard tasks at about two dollars and forty cents each. The trap is the top-left: a cheap token that becomes dear work because the model cannot finish. Fable 5.1 sits off to the right, dear on both axes in this model — and its position is the most fragile on the board, because its estimate leans entirely on Fable 5's top-tier solve rate. There is real evidence token-burn varies wildly: on one measured comparison, a rival model finished tasks on sixteen thousand output tokens where Opus 4.8 spent thirty-three thousand — twice the burn for the same job. If Fable 5.1 finishes as reliably as its benchmarks suggest and stays lean, a dear token still buys a competitive task. If it thrashes, it slides straight into the trap. The honest answer today is that we do not know, the vendor's cost-per-task claim rests on one partner's word, and the number that would settle it has not been independently measured.

A re-based class, not a stale one

Exhibit — Fable 5.1 is a real generational lift — and now edges Opus 5 on agentic work. The class moved: Terminal-Bench-Science more than doubled 5→5.1, and 5.1 tops Opus 5 on all three. Source: Anthropic, "Introducing Claude Fable 5.1 and Mythos 5.1" model card. As of Sep 2026.
Exhibit — The mythos class spent months behind glass before it became your coding model. "Sitting around" was safety-gating, not neglect — the case for a careful, well-adjusted release. Source: Anthropic announcements & model cards; TechCrunch (9 Jun 2026); InfoQ (Jun 2026). As of Sep 2026.

So is Fable 5.1 a genuine new generation, or a cosmetic bump on a model that has been sitting on a shelf? The history answers the sharpest version of that question, and it reframes the model before you read a single benchmark. The "mythos class" is a specific lineage, not marketing gloss. Anthropic finished training a model it called Mythos in April 2026 and then declined to release it, judging it too dangerous for open access and handing it only to vetted partners under a program called Project Glasswing. Fable is the public, guardrailed sibling of that same model. The name is the tell — fable, from the Latin for "that which is told," a deliberate echo of mythos.

That matters for the intuition that a slow release is a well-adjusted one: here it holds, because the class matured under safety review rather than neglect. And the benchmarks say re-based, not retouched. On Terminal-Bench 4.0, an agentic coding-in-a-terminal test, Fable 5.1 scores 55.8 per cent against Fable 5's 42.0. On the harder Terminal-Bench-Science it more than doubles, from 24.7 to 52.6. On AutomationBench it climbs from 17.1 to 31.4.

Two honest caveats. These are the vendor's own figures, the most favorable framing available; an independent reviewer who normalized frontier models on a real coding harness this year found published numbers routinely overstated once the harness changed. And the class tops out higher still in private hands — the restricted Mythos 5.1 sibling reaches 60.9 on Terminal-Bench 4.0, a reminder that the public number is the guardrailed one. Read the shape — a real jump — more than the decimal.

Anthropic needs a win

Here is the frame that has been circulating among practitioners, and it is worth taking seriously: Anthropic needs a win. The reasoning goes that Opus 5, launched on July 24th, was rushed out to answer OpenAI and landed badly. The evidence for the "landed badly" half is strong and well-documented. Opus 5 beat its predecessor on essentially every published benchmark, sometimes by ten points — and earned a rare, damning verdict from the people using it: the best model many had tried, and the one they least enjoyed working with. Reviewers described it as verbose, neurotic, and prone to treating a small edit as a major operation, with a measurably higher hallucination rate and a slow first response at maximum effort. It looked better on paper and, for real workflows, was harder to use — the exact trap we mapped in episode 42, on why the top-scoring model often can't do what you ask.

The competitive pressure is real too. By late summer OpenAI's GPT-5.6 Sol had caught up and drawn genuine praise as the best broad default for coding; Chinese open-weight models kept closing the gap and eroding share; commentators openly described the pressure on Anthropic as "mounting by the hour." Against that backdrop, a patient, polished Fable 5.1 does read like a redemption arc — the careful release that restores the reputation a rushed one dented.

But hold the frame at arm's length, because there is a cleaner counter-read. Fable is a different tier from Opus — the top of the range, priced at twice Opus — so a strong Fable 5.1 does not actually fix the thing people disliked about Opus 5; it is a more expensive model most of those users will not switch to. And "point-one" releases on a roughly quarterly cadence are exactly what every lab now ships. So the "needs a win" story is emotionally satisfying and partly true — the reception gap was real, the pressure is real — but it may be over-reading a normal cadence release as a rescue mission. The more interesting question is what, precisely, would even count as the win. And the answer, this summer, was not a model.

The harness, not the model

Exhibit — Anthropic deleted ~80% of Claude Code's harness — and the evals didn't move. Same models, no benchmark loss — proof that the scaffolding, not the weights, was a huge share of the variable. Source: Anthropic, "The new rules of context engineering for Claude 5 generation models"; Thariq Shihipar, AI Engineer World's Fair, 24–25 Jul 2026.

Here is the concept everything from here turns on, because it is the most misunderstood idea in AI right now. A raw language model is not an agent. What you actually use — Claude Code, Cursor, an autonomous coding tool — is the model wrapped in a harness: the system prompt that tells it how to behave, the definitions of the tools it can call, the loop that decides when it acts and when it stops, and the project files and memory fed in around every request. The model supplies the raw intelligence. The harness decides whether that intelligence ever reaches your problem intact. Change the harness and you can make the identical model weights go from useless to excellent — or the reverse — without touching the model at all.

This is not theory. In late July, Anthropic's own engineer Thariq Shihipar stood up at a developer conference and revealed that the company had deleted more than eighty per cent of Claude Code's system prompt for its newest models — and measured no loss on coding evals. The prompt shrank from roughly twenty-seven hundred words to around five hundred. The company published its reasoning in a piece that reads like a confession: "we were overconstraining Claude Code, both through our system prompt and in our CLAUDE.md files and skills." The instructions written to make the tool reliable were making it worse — one rule saying to document as appropriate, another saying never add comments, and the model burning reasoning to decide which won before it could touch a file.

If the same tool gets dramatically leaner with no capability loss, then a large share of what people were experiencing as "the model" was really the scaffolding all along. This is the argument this show made in full in our harness episode, number 48 — on how the scaffolding, not the weights, decides half of whether AI works. Independent work makes the point even sharper: security firm Endor Labs ran the same Fable 5 model through two different agent harnesses and watched its success rate swing by more than twelve points. Same weights, same tasks — different words around them, different outcome. This is why "the new model feels amazing" and "the new model feels broken" can both be true in the same week from two people running different scaffolds. The lesson Anthropic drew is the one every serious practitioner is converging on: when the model gets smarter, the right move is to delete instructions, not add them.

What changed in your hands

Which brings us to the lived experience — including this show's own, offered as exactly one data point and labeled as such. Over the past several days, our own coding work with Opus 4.8 went from productive to nearly unusable: instructions ignored, unprompted actions, confident conclusions drawn from broken inputs. And an hour of fresh testing with Fable 5.1 felt like stepping onto solid ground again. That is a real observation. It is also anecdotal, recent, and easy to misattribute — which is the whole reason the model-versus-harness distinction matters. So let us separate what we actually know into four honest tiers.

First, what got observed: a sharp, recent, personal drop in Opus 4.8's usability. Second, what corroborates it with dates. The exact pattern — Opus 4.8 agents ignoring explicit instructions and acting on incomplete data — was filed publicly against Claude Code back in June, where it hit multiple independent sessions and a separate Anthropic tool simultaneously with no user config change, which points at the serving stack or the harness, not the user. In this show's own recent window, Anthropic's status page logged degraded-output incidents across other Claude models from early August into early September. The phenomenon of a good model quietly going bad underneath you is documented and real — though note the strongest public evidence is weeks older than any single recent session, so the precise "last few days" claim stays anecdotal. Third, what Anthropic has actually confirmed: the eighty-per-cent harness deletion, and — tellingly — that it shipped with Opus 5 in late July, not with Fable 5.1. Fourth, what remains unverified: that a specific harness change in the last week "unlocked" Fable 5.1, or that the same change silently rehabilitated Opus 5. Those are plausible and unproven.

Put together, the honest reading inverts the intuitive one. The feeling that Fable 5.1 "just works" is genuine and probably real — but the biggest harness rewrite of the year landed six weeks before it, alongside the model everyone complained about. So some of the credit Fable 5.1 is collecting for feeling good may belong to a scaffolding fix that a rougher model got blamed for missing. The model improved. The harness improved more, earlier, and quietly. And when both move at once, the human instinct is to credit the shiny new model and never look at the plumbing.

Bottom line

Fable 5.1 is a real generational lift, not a stale model in new packaging — the mythos class genuinely evolved, and on agentic work it now leads Opus 5. It is also the most expensive token on the frontier, which makes its whole value proposition rest on a number that does not yet exist: verified cost per completed task. "Anthropic needs a win" is a satisfying story with a true core and an over-read: the Opus 5 reception really was rough and the competitive heat is real, but a pricier top-tier model is a strange redemption for a mid-tier complaint. And the deepest lesson is the one hiding in plain sight — the summer's biggest change in how these models behave came from deleting eighty per cent of the harness, not from any new weights. Expect Fable 5.1 to be good. Before you believe it is cheap, measure a finished task. And before you credit the model for how it feels, check whether it was the model that changed — or the words wrapped around it.

Sources

Transcript

Sam: Anthropic just shipped its best coding model yet — and it's the single most expensive token on the whole frontier.

Alex: And here's the twist: the thing that actually changed how it works this summer wasn't the model at all. It was the harness wrapped around it.

Sam: Same weights, no new training — and it can go from thrashing to brilliant because someone rewrote the instructions.

Alex: Cheap tokens, it turns out, have never been the same thing as cheap work. That's the whole episode. Welcome back to Dan's AI Intel — the show where we take the one question in AI that actually matters that week and dig past the hype and the fear to what's really going on underneath.

Sam: Because the field moves so fast that the story everybody repeats is usually the wrong one — and this week is a perfect example of that.

Alex: I'm Alex, here with Sam, and today we're getting into Anthropic's newest coding model, Fable 5.1.

Sam: On paper it's a real step up. It also lists at the highest price on the board. So the obvious question is, is it worth it — but that's not actually the interesting question.

Alex: The interesting question is what "cheap" even means when a token is the priciest on the frontier, and whether the thing everyone's excited about is the model — or something quieter sitting right next to it.

Sam: We'll walk the price sheet, the benchmark jump, this story going around that "Anthropic needs a win" — and then the part almost nobody's talking about, which is the scaffolding wrapped around the model.

Alex: And we'll get to why the exact same model can feel amazing to one person and broken to another in the very same week — and why that's not a contradiction at all.

Sam: If you're enjoying the show, do hit follow wherever you're listening — it's free, and it's the easiest way to make sure the next one finds you.

Alex: So let's start where it's strangest, which is the price. Fable 5.1 lists at ten dollars per million tokens going in, and fifty dollars per million coming out.

Sam: Fifty dollars out. And just to ground people — how does that stack up against the models they might already be using?

Alex: It's the top of the board, and it's not close. The next one down is OpenAI's GPT-5.6 at thirty dollars out. Anthropic's own Opus 5 is twenty-five. Gemini 3.1 Pro is twelve. Sonnet 5 is ten, and the little workhorse Haiku is five.

Sam: So Fable is what, five times the price of Sonnet on the output side. Why do we keep hammering the output number specifically?

Alex: Because for a reasoning model, output is the number that dominates the bill. These models think out loud before they answer — and you get charged for every one of those hidden thinking tokens at the output rate.

Sam: Ah — so the part you never even see is the part running up the meter.

Alex: Exactly. And those invisible thinking tokens can outnumber the visible answer many times over. So "fifty dollars per million out" hits harder than it looks on the sticker.

Sam: Okay, but here's what I don't get. If Anthropic knows it's the most expensive token on the board, why would they lead with that? What's the pitch?

Alex: This is the tell, and it's really important. When you read what Anthropic actually says about 5.1, they barely talk about the token price — because the token price didn't move. It's identical to the last version.

Sam: So what do they talk about instead?

Alex: They say if you run it at low or medium effort, it matches the old model's quality for less money. They say typical workloads come out about twenty-five per cent cheaper, agentic ones up to forty-five per cent cheaper, and they cut a background cost called cache reads by seventy-five per cent.

Sam: Every one of those is a saving, though. So where's the sleight of hand?

Alex: Look at what those claims are actually about. Not the price of a token — that's fixed. They're about how much useful work the model gets done per token. That is a completely different axis. And it happens to be the only one that matters.

Sam: Okay, spell that out, because "cost per token versus useful work per token" sounds like a distinction without a difference.

Alex: It's the whole ballgame, so let me make it concrete. The number that actually matters isn't what a token costs — it's what a finished task costs. Solve one real bug. Complete one agent loop. What did the whole job cost you, start to finish?

Sam: And that folds in more than the price tag.

Alex: It folds in three things. One, the price per token. Two, how many tokens the model burns thrashing around on its way to the answer. And three — the big one — how often it actually finishes at all.

Sam: So a model could be dirt cheap per token and still be the expensive choice, if it flails and retries and burns five times as many tokens.

Alex: That's exactly it. Cheap tokens are not cheap work. And this isn't hypothetical for us — we did a whole episode on this, number 24, a couple of months back. The one where Sonnet got cheaper on the sticker and people's bills somehow went up.

Sam: Right, because the cheaper model was doing more fumbling per task, so the total went the wrong way.

Alex: The sticker fell and the bill rose. Same paradox, back again — and now it's pointed at the most expensive token on the board.

Sam: So where does Fable 5.1 actually land on cost per task? That's the number I want.

Alex: And here's the honest, slightly frustrating answer: nobody knows yet. Clean, independent cost-per-task numbers barely exist for anything — and for Fable 5.1 specifically, they don't exist at all. It's days old.

Sam: So anything we say about its real task cost is a guess.

Alex: It's a model, and we label it as a model. If you plot the frontier fleet on those two axes — price per token going one way, estimated cost per finished task the other — the rankings visibly scramble. They do not line up.

Sam: Give me the shape of it. Where does the good stuff live?

Alex: Bottom-left is the prize: cheap per token and cheap per task. That's where the workhorses sit — Sonnet 5 resolves roughly three in four standard coding tasks at around two dollars forty a task. Solid, boring, cheap.

Sam: And the trap?

Alex: Top-left. A token that looks cheap but becomes expensive work, because the model can't reliably finish. Cheap ticket, dear ride.

Sam: And Fable 5.1?

Alex: In this model it sits off to the right — dear on both axes. And its position is the most fragile on the whole board, because the estimate leans entirely on the assumption that it finishes tasks as reliably as its benchmarks suggest.

Sam: Which we don't actually know yet.

Alex: Which we don't. And there's real evidence this stuff swings hard. On one measured head-to-head, a rival model finished the same tasks on sixteen thousand output tokens where an Anthropic model spent thirty-three thousand. Twice the burn, same job.

Sam: Twice. So if Fable 5.1 runs lean, a dear token can still buy you a competitive task —

Alex: — and if it thrashes, it slides straight into the trap. Today we genuinely don't know which. The vendor's cost claim rests on one partner's word. The number that would settle it hasn't been independently measured. So: treat the score as real, and the cost-per-task story as wide open.

Sam: Okay, so let's talk about whether this is even a real new model — or a stale one in shiny packaging. Because you hinted the history changes how we should read it.

Alex: It completely reframes it, and this is my favourite part. Fable belongs to something Anthropic calls the "mythos class." And that's a specific lineage, not marketing gloss.

Sam: Tell me the lineage.

Alex: Back in April, Anthropic finished training a model it called Mythos. And then it did something unusual — it declined to release it. Judged it too dangerous for open access, and handed it only to vetted partners under a program called Project Glasswing.

Sam: Too dangerous to ship. So how do we end up using it in a coding tool?

Alex: Because Fable is the public, guardrailed sibling of that same model. And the name is the giveaway — "fable," from the Latin for "that which is told." A deliberate echo of "mythos." They're telling you it's the same bloodline, tamed for daylight.

Sam: I love that. Okay, so walk me through how it actually got to us — because there was a whole saga, wasn't there.

Alex: There was. April, Mythos is trained and withheld. June the ninth, the first public version — Fable 5 — ships. Three days later, June twelfth, access gets suspended.

Sam: Suspended? Three days in? Why?

Alex: US export controls. They couldn't reliably verify the nationality of some users, so they pulled it rather than risk it. It comes back July first when the controls are sorted. And then, this week, September first — Fable 5.1, the re-based generation.

Sam: So the natural instinct — that this thing's just been sitting on a shelf gathering dust —

Alex: — the honest read is the opposite. It wasn't neglected. It was maturing behind safety review the whole time. And that actually supports the idea that a slow, patient release tends to be a well-adjusted one. Here, the delay was the point.

Sam: Right, but "well-adjusted" is a vibe. Do the benchmarks back up that it genuinely moved, versus a cosmetic bump?

Alex: They back it up, and it's not subtle. Take Terminal-Bench — that's a test of coding agentically inside a real terminal. The old Fable 5 scored forty-two per cent. Fable 5.1 scores fifty-five point eight.

Sam: Okay, that's a real jump. What about the harder stuff?

Alex: The harder sibling test, Terminal-Bench-Science, it more than doubles — from twenty-four point seven up to fifty-two point six. And on a third one, AutomationBench, it climbs from seventeen up to thirty-one.

Sam: And how does that stack against Opus 5 — the model most developers actually reach for by default?

Alex: This is the headline: on all three of those agentic tests, Fable 5.1 now edges out Opus 5. The class didn't idle. It re-based.

Sam: I want to be the skeptic for a second, though. Those are Anthropic's own numbers, right? The most flattering framing available.

Alex: They are, and you should hold them at arm's length. An independent reviewer who re-ran frontier models on a real coding setup this year found the published figures routinely overstated once you changed the setup around them. Hold that thought, by the way — it comes back hard later.

Sam: Noted. Anything else on the caveats?

Alex: One more, and it's a good reminder of what we're actually looking at. The restricted sibling — Mythos 5.1, the one behind the glass — scores higher still, almost sixty-one on that same terminal test. So the number we get is the guardrailed one. Read the shape, a real jump, more than the exact decimal.

Sam: Okay, so there's this frame going around among developers I want to put to you directly: "Anthropic needs a win." Is that real, or is that just internet mood music?

Alex: It's worth taking seriously, because half of it is very well documented. The story goes: Opus 5 launched on July twenty-fourth, felt rushed out to answer OpenAI — and landed badly.

Sam: But didn't Opus 5 beat the old model on basically every benchmark?

Alex: It did. Sometimes by ten points. And it still earned this rare, kind of damning verdict from the people using it every day: the best model many of them had tried, and the one they least enjoyed working with.

Sam: The best one they least enjoyed. Unpack that, because it sounds contradictory.

Alex: Reviewers called it verbose, a bit neurotic, prone to treating a tiny edit like a major operation. Measurably higher hallucination rate. Slow to give you a first response when you cranked it to maximum effort. Better on the scoreboard, harder to actually use.

Sam: And that is a pattern this show has hit before.

Alex: It's the exact trap we pulled apart in episode 42, just a few weeks ago — the one on why the top-scoring model so often can't do the thing you actually asked it to do. Opus 5 walked right into it.

Sam: So the "landed badly" half checks out. What about the competitive pressure half?

Alex: That's real too. By late summer, OpenAI's newest had caught up and was drawing genuine praise as the best all-round default for coding. Chinese open-weight models kept closing the gap and eating into share. Commentators were openly describing the pressure on Anthropic as mounting by the hour.

Sam: So against that backdrop, a patient, polished Fable 5.1 really does read like a redemption arc.

Alex: On the surface, absolutely. The careful release that restores the reputation a rushed one dented. It's a satisfying story.

Sam: But you've got a "but" loaded. I can hear it.

Alex: I do, because there's a cleaner counter-read. Fable is a different tier from Opus. It's the top of the range, priced at roughly twice Opus. So a brilliant Fable 5.1 doesn't actually fix the thing people disliked about Opus 5.

Sam: Because the people grumbling about Opus 5 aren't going to jump to a model that costs double.

Alex: Most of them won't. It's a more expensive model in a different lane. And on top of that — a point-one release on a roughly quarterly cadence is just what every lab ships now. It's a Tuesday.

Sam: So "Anthropic needs a win" is —

Alex: — emotionally satisfying, and partly true. The Opus 5 reception really was rough, the competitive heat is real. But it might be over-reading a totally normal cadence release as some kind of rescue mission. A pricier top-tier model is a strange way to answer a mid-tier complaint.

Sam: So if the win isn't the pricier model... what would even count as the win this summer?

Alex: That is exactly the right question. And the answer, it turns out, wasn't a model at all.

Sam: Okay, you've been teasing this the whole episode. The harness. What is it?

Alex: This is the most misunderstood idea in AI right now, so let me build it carefully. A raw language model, on its own, is not an agent. It's just intelligence in a box.

Sam: So the thing I'm actually using — Claude Code, Cursor, whatever — that's not just the model.

Alex: Right. What you're using is the model wrapped in a harness. And the harness is four things: the system prompt that tells it how to behave, the definitions of the tools it's allowed to call, the loop that decides when it acts and when it stops, and the project files and memory fed in around every request.

Sam: So the model is the engine, and the harness is... the whole rest of the car.

Alex: That's a good way to hold it. The model supplies the raw intelligence. The harness decides whether that intelligence ever reaches your actual problem intact. And here's the kicker — change the harness, and you can take identical model weights from useless to excellent. Or the reverse. Without touching the model at all.

Sam: Okay, that's a big claim. Same brain, totally different behaviour, just from changing the instructions around it. Do we actually have proof of that, or is it theory?

Alex: We have a confession. And it's a good one. Late July, an Anthropic engineer named Thariq Shihipar stands up at a developer conference and reveals that the company had deleted more than eighty per cent of Claude Code's system prompt for its newest models — and measured no loss on the coding evals.

Sam: Eighty per cent — of the instructions they'd written to make the tool good?

Alex: Gone. The prompt shrank from around twenty-seven hundred words down to about five hundred. And they published their reasoning in a piece that honestly reads like an apology. The line was: we were overconstraining Claude Code — through the system prompt, and through the memory files and skills.

Sam: Overconstraining. So the instructions meant to make it reliable were making it worse?

Alex: In many cases, yes. My favourite example: one rule said document your code where appropriate. Another rule said never add comments. And the model would sit there burning reasoning trying to figure out which rule won — before it could even touch a file.

Sam: Oh, that's painful. It's arguing with its own instructions instead of doing the work.

Alex: And the moment you delete the contradiction, it just... gets on with it. Same model. Fewer words around it. Dramatically better.

Sam: So how much of what people experienced as "the model got better" was really "the scaffolding got out of the way"?

Alex: A large share of it. And this is the thing we did a whole episode on — number 48, just last week — how the scaffolding, not the weights, decides something like half of whether AI actually works for you.

Sam: Is there independent proof, though? Not just Anthropic marking its own homework?

Alex: There is, and it's even sharper. A security firm called Endor Labs took the same Fable 5 model and ran it through two different harnesses. Its success rate swung by more than twelve points. Same weights, same tasks — different words around them, different outcome.

Sam: Twelve points from nothing but the wrapper. So "the new model feels amazing" and "the new model feels broken" —

Alex: — can both be completely true, in the same week, from two people running different scaffolds. It was never a contradiction. They're just describing different harnesses and blaming the model.

Sam: So what's the lesson Anthropic themselves drew from all this?

Alex: The one every serious practitioner is converging on: when the model gets smarter, the right move is to delete instructions, not pile more on. Trust it more, hand-hold it less.

Sam: Okay, this is where it gets personal, because this show's own experience feeds right into it. Tell people what happened.

Alex: So — offered as exactly one data point, and labelled as such. Over the past several days, our own coding work with the older Opus 4.8 went from productive to nearly unusable. Instructions ignored. Actions taken we never asked for. Confident conclusions drawn from broken inputs.

Sam: And then?

Alex: An hour with Fable 5.1 felt like stepping back onto solid ground. That's a real observation. It's also recent, anecdotal, and really easy to misattribute — which is the entire reason the model-versus-harness distinction matters so much here.

Sam: So how do we keep ourselves honest about it? Because "it felt better" is exactly the kind of thing that fools people.

Alex: We split what we know into four honest tiers, from most solid to most speculative. Tier one — what got observed. A sharp, recent, personal drop in that older model's usability. Real, but it's one person's experience.

Sam: Tier two?

Alex: What corroborates it, with dates. That exact pattern — the model ignoring explicit instructions and acting on incomplete data — was filed publicly against Claude Code back in June. And it hit multiple independent sessions and a separate Anthropic tool at the same time, with nobody changing their settings.

Sam: And if it hits everyone at once with no config change, that points away from the user.

Alex: It points at the serving stack or the harness, not you. And the status page logged degraded-output incidents across other models from early August into early September. So the phenomenon of a good model quietly going bad underneath you is documented and real.

Sam: But?

Alex: But the strongest public evidence is weeks older than any single recent session. So the precise "it got bad in the last few days" claim stays anecdotal. We hold it loosely.

Sam: Okay. Tier three — what's actually confirmed?

Alex: The eighty per cent harness deletion. That's on the record. And here's the detail that reframes everything: it shipped with Opus 5, back in late July. Not with Fable 5.1.

Sam: Wait. The big harness rewrite went out with the model everyone complained about — six weeks before the model everyone's now praising?

Alex: Six weeks before. Hold that. Tier four — the unverified stuff. That some specific harness tweak in the last week "unlocked" Fable 5.1, or quietly rehabilitated Opus 5. Both plausible. Neither proven.

Sam: So when you put all four tiers together, what's the honest reading?

Alex: It inverts the intuitive one. The feeling that Fable 5.1 just works is genuine, and probably real. But the biggest harness rewrite of the year landed six weeks earlier, alongside the model people hated.

Sam: So some of the credit Fable 5.1 is collecting for feeling good —

Alex: — may actually belong to a scaffolding fix that an earlier, rougher model got blamed for missing. The model improved. But the harness improved more, earlier, and quietly. And when both move at once, the human instinct is to praise the shiny new model and never once look at the plumbing.

Sam: Okay, bring it home. If someone's got thirty seconds, what are the two or three things they walk away with?

Alex: First: Fable 5.1 is a real generational lift, not a stale model repackaged. The mythos class genuinely evolved, and on agentic work it now leads Opus 5. That part is settled.

Sam: Second?

Alex: It's also the most expensive token on the frontier, which means its entire value rests on a number that does not yet exist — verified cost per finished task. Expect it to be good. But before you believe it's cheap, measure a real job, end to end.

Sam: And the "Anthropic needs a win" story?

Alex: True core, over-read. The Opus 5 reception really was rough and the pressure is real — but a pricier, top-tier model is a strange redemption for a mid-tier complaint. Be careful with that narrative.

Sam: And the big one. The thing hiding in plain sight.

Alex: The summer's biggest change in how these models behave didn't come from new weights. It came from deleting eighty per cent of the harness. So before you credit a model for how it feels — check whether it was the model that changed, or just the words wrapped around it.

Sam: That's the reframe I'm taking with me. It's so easy to fall in love with the engine and never look at the rest of the car.

Alex: And that's the whole game right now. The intelligence is getting cheaper and better. But whether it reaches your problem intact is a scaffolding question — and that's the part almost nobody's watching.

Sam: And that's it for today — thank you so much for spending it with us.

Alex: I hope you came away seeing a bit more clearly where all of this is heading. It's a genuinely complex, fast-moving picture with a brutally short shelf life on what you know — and honestly, that's exactly what makes it worth following this closely.

Sam: One honest note on how this show is made: it's AI-generated. Dan builds a custom stack of AI tools to research, analyse, verify and illustrate the questions worth understanding — mostly to learn them himself, and he shares what he finds. AI-assisted, fact-checked, and always worth a second look. You can find the whole show, and the full written report behind this episode, at connectiveshift.com.

Alex: And before you go, one genuinely useful thing you can do: follow the show. Whatever app you're listening in right now, there's a follow or a plus button — it's one tap, it's free, and it does two things.

Sam: You'll get each new episode the moment it lands — and for a small, independent show like this one, a follow is honestly the single biggest lever there is for helping it reach other people trying to make sense of all this.

Alex: So if today was worth your time, go ahead and hit that follow button.

Sam: And one last thing before you head off. If there's someone in your life who keeps asking you where AI is actually heading — send them this episode.

Alex: Genuinely, it's one of the kindest things you can do, for them and for us. It's still a small, independent show, and every single share does far more than you'd think.

Sam: Thanks for listening — and we'll see you in the next one.