The Most Expensive Houseguest
Claude Fable 5 shipped on the ninth of June - Anthropic's new top tier, a class above the Opus line, with a subscription window running to the 22nd. It moved into the workshop the same day, and Greebo, the machine's resident agent, has been running on it since. It is, without much competition, the best model we have ever pointed at real work. It is also the most expensive houseguest we have ever had, and it arrived into a house furnished entirely for its predecessors. This article is about both of those problems, because we solved them inside the model's first seventy-two hours - and is being written on day two of its existence, which tells you something about the pace this fortnight has set.
The plan, written in sensible ink, said: run the new model on the subscription for the fortnight, then revert to Opus 4.8 and carry on. The plan did not survive day one. A single Fable 5 working prompt - the multi-agent kind this workshop actually runs - can max out a subscription allowance by itself, so we went straight to the API and have been paying list rates since. What the 22nd really ends is the deferral: keep drawing down a credit pile of nearly $300,000 that we have been sitting on like a dragon with a current account, or settle back onto Opus 4.8 and bank the difference. Both doors are open. This article is being written with a foot in each.1
// the renovation
Here is the part nobody warns you about when a frontier model ships: your software is now wrong. Not broken - wrong the way a house is wrong for a new tenant. Every rule, hook, skill and instruction file on this machine had been tuned, over months, for the previous generation of models. The new one arrived into all of it at once.
So before anything else - on the model's second day of existence - we audited: seventeen agents pointed at the machine's own configuration for an evening, reading it the way an archaeologist reads a midden, not for what it says but for when each layer was deposited.2 Seventy-five findings. The interesting ones were not bugs. They were fossils.
The single biggest artifact: a reasoning ritual - restate the question in fully concrete terms before answering - bulk-stamped into sixty-three files back in February. Every agent profile. Two dozen skills. Both instruction files that load into every session. A sensible nudge for February's model, applied with the thoroughness of someone who has just discovered a good trick. Four months later, Anthropic's own guidance for the new model reads: "Skills developed for prior models are often too prescriptive for Claude Fable 5 and can degrade output quality." Worse, Fable 5 polices a refusal category - reasoning_extraction - around requests to expose its internal reasoning as response text, and a forced restatement ritual lives uncomfortably close to that category. The helpful incantation had become a small tax on every session and a refusal risk in the corner cases, sixty-three times over.
It was not alone. The audit found threat-style emphasis blocks - accusations of dishonesty, warnings of replacement - written to keep an older, lazier model honest, which the new model follows with the unsettling literalism of a new employee reading the fire-evacuation poster. It found delegation guardrails written for a model that under-used helpers, now constraining a model that dispatches sub-agents the way other people use tabs. None of this was anyone's mistake. Rules outlive the models they were written for, because nobody dates their incantations.3 The renovation was not optional even if we had planned to revert on the 22nd: the fossils were degrading the expensive houseguest today.
// folklore vs the manual
The audit worked from primary sources rather than the rumour mill - of five claims doing the rounds on X that week, four died on contact with the documentation. The one that survived was the important one: Fable 5 and Opus 4.8 genuinely want different prompting, and the official guidance reverses between them. Fable dispatches sub-agents readily and should be steered toward asynchronous delegation; Opus under-reaches and needs explicit triggers. Fable drifts into dense shorthand in long sessions and needs a readability addendum; Opus narrates too much and wants a silence default. Both ship the same effort default; Opus's documentation says to push the dial a notch higher for agentic work, Fable's says the default is already right. A single shared configuration cannot serve both minds. Whatever you write for one is, by the published guidance itself, partly wrong for the other.
| Fable 5 | Opus 4.8 | |
|---|---|---|
| Delegation | dispatches sub-agents readily; steer towards asynchronous delegation | under-reaches; needs explicit triggers |
| Readability | drifts into dense shorthand in long sessions; needs a readability addendum | narrates too much; wants a silence default |
| Effort | same default; the default is already right | same default; push the dial a notch higher for agentic work |
A comparison table with two columns, Fable 5 and Opus 4.8, and three rows. Delegation: Fable 5 dispatches sub-agents readily and should be steered towards asynchronous delegation; Opus 4.8 under-reaches and needs explicit triggers. Readability: Fable 5 drifts into dense shorthand in long sessions and needs a readability addendum; Opus 4.8 narrates too much and wants a silence default. Effort: both ship the same effort default; for Fable 5 that default is already right, while for Opus 4.8 the documentation says to push the dial a notch higher for agentic work.
// two minds, one wardrobe
Which would be an academic observation if only one mind lived here - but it does not, and will not, whichever way the 22nd goes. Opus 4.8 is the standing fallback even in the all-API future: it is the official routing target when Fable's safety classifiers false-positive on benign security-review work, it is the second seat in our two-agent review pattern precisely because it fails differently, and it is the mind the whole machine reverts to if the credit pile or the judgment changes. Two minds around one machine, permanently.
So the renovation's architecture had to serve both, and the rule we landed on is the part worth stealing. Model-agnostic fixes apply destructively: bugs, duplication, dead config - things wrong for any mind - get fixed in place, permanently. (Three hooks turned out to be printing their rejection reasons onto a channel the model never sees, which is a bug under every model that will ever exist.) Model-specific tuning never touches shared files. It lives in per-model profile documents - one per mind, carrying only the deltas the published guidance actually justifies - injected at session start by a small hook that checks which model is active. Every kind of session inherits the right profile for free: interactive, headless, the crons, the daemon. Switching minds, for a day or forever, is one edited line in one settings file. The wardrobe swaps; nothing is tattooed.
One field note, because the gap between documentation and runtime is where these projects live: the docs say the session-start hook receives the model's identity. In the shipping version it does not, so the hook resolves it from the environment and the settings file - caught in the hour of validation the design had budgeted, because docs-says-so is not runtime-does-so.4 We also put the configuration directory under version control before touching any of it, which it turns out it had never been, a sentence I type with the serenity of a man whose backups have already been taken.
// the canary
Then there was the failure mode that justified the whole exercise. The machine's model is one alias in one settings file, inherited by everything.1 On the 22nd, that alias either stops resolving - in which case the always-on daemon dies at its first call, and its Restart=always unit plus its watchdog produce an infinite, silent restart loop, a machine politely concealing its own death - or it re-points, and every piece of automation switches minds with zero notice. Before this month, nothing was watching for either.
Now something is. The daily health check grew a model canary: a tiny headless session, run with no model flag so it inherits exactly what the automation inherits, whose resolved model id is read mechanically out of the response metadata - not by asking the model, because models will cheerfully claim to be all sorts of things.5 The id is logged daily; a day-over-day change raises an alert. Next to it, a crash-loop detector watches the daemon's restart counter. Total cost: one trivial call a day and a systemd query. Whichever mind answers on the morning of the 23rd, the canary line will be the first thing on the machine that says so out loud.
// what stayed
An audit that only condemns is a demolition survey, and this one validated more than it tore down - thirty-nine keep-items rode alongside the seventy-five findings. The house verification rule (state the success condition, run the command, read the output, then claim the result) turned out to match Fable 5's official progress-grounding guidance nearly word for word - and the rule predates the guidance by months. The memory-capture conventions matched the published memory-format guidance the same way. Everything model-facing was already alias-based, so nothing 404s on a retirement date. Convergent evolution is quietly reassuring: when your home-grown discipline and the vendor's eventual guidance arrive at the same sentence, the discipline was load-bearing.
// the rehearsal
And because an intention is not a guarantee, the fallback got rehearsed before the window closes: Opus 4.8, with its profile, on real work - headless first, since headless is where the risk lives. The rehearsal earned its keep by almost lying: the first probe quietly inherited behaviour from the session that launched it, exactly the kind of contamination that makes a test pass for the wrong reasons. Scrubbed and re-run: clean, first try. A fallback you never rehearsed is a hope, not a fallback. Ours is rehearsed.
// what a conversation costs now
So much for the house; now the rent. Let us be precise about the houseguest's appetites, because nobody else publishing about this model seems to want to be. Fable 5 bills at twice Opus rates, and its tokenizer runs roughly thirty percent heavier on identical text - the same words simply cost more to think about. These are not hypothetical numbers - they are our costs so far, tallied from the session transcripts themselves, every API call at its model's rates.6 The model has existed for three days. In them: seven sessions over $200, just over $5,000 of API in total - around $4,500 of it inside a day and a half of actual use - and a record of $1,755 for a single session: three thousand API calls, one evening, the seventeen-agent audit from the renovation above. One conversation that cost five times as much as the entire computer we built in the last article, a comparison I have chosen not to find upsetting.
The sticker shock deserves its context, though. Those sessions are not chat. A $200 session is a research fan-out that reads forty primary sources and adversarially re-verifies its own findings before reporting back; the $1,755 record bought the audit - every rule, hook and skill on the machine read and judged in a single evening. The model does in an evening what used to be a fortnight of part-time digging, and it does it correctly on the first pass often enough that the bill per outcome - rather than per token - keeps coming out embarrassingly reasonable. It helps that the caching discipline held up under audit: two identical sessions reuse 99.97% of their prompt prefix, and at ten dollars per million input tokens that is the difference between the credit pile lasting a year and lasting a quarter. The credits make the experiment affordable; the results are what make it rational. At current appetites the pile lasts somewhere between a year and rather less than that, depending on how many audits we commission, which is why the daily cost check now sits in the same health report as the disk space.
The fair comparison, though, is not per token but per piece of work, normalised against what Opus 4.8 would charge for the same outcome. The naive arithmetic is brutal: twice the rates times a third more tokens is roughly two and a half times the bill for identical text, so any task Opus handles cleanly in one pass is money burnt with extra steps on Fable. The premium earns out only where the work changes shape. The seventeen-agent evening came back first-pass-correct at a scale we would simply not have pointed Opus at in one go, and a task that needs two or three Opus iterations - or a human untangling a half-right result - closes most of a 2.5x gap by itself. Two days in, the honest scorecard reads: on routine work, Opus economics win and the wardrobe should route accordingly; on the genuinely hard work, Fable comes out even or ahead per outcome despite the meter. The ledger will re-litigate that sentence before the 22nd.
For a sense of how far off the enterprise map this is: Anthropic's own telemetry puts the average enterprise deployment at $13 per developer per active day, with ninety percent of users under $30. Uber made the news this month for capping engineers at $1,500 a month per tool, after its annual AI budget evaporated in four months and its COO admitted the ROI link is "not there yet". Our day and a half of June equals a capped Uber engineer's entire quarter. Whether that makes us a preview of where enterprise spend is heading or simply a cautionary anecdote with a blog is, genuinely, one of the things the next few months will tell us.
A horizontal chart on a logarithmic dollar scale from 10 to 10,000. Four muted rows for enterprise spend: Anthropic's enterprise average of $13 per developer per active day; ninety percent of users under $30 per developer per active day; the pain threshold enterprises actually enforce, perhaps $50 to $100 per developer per day; and Uber's cap of $1,500 per engineer a month per tool. Two amber rows for this workshop: seven sessions over $200, up to the record of $1,755 for a single evening; and around $4,500 spent inside a day and a half of actual use, which equals a capped Uber engineer's entire quarter.
// who is actually paying
A reasonable question at this point - one I asked myself while watching the meter spin - is who actually absorbs numbers like these. The fashionable answer is "venture capitalists, the way they absorbed the taxis and the takeaways", and it turns out to be wrong in an instructive way.
The list-rate tokens are not subsidised. The best outside reconstruction has frontier inference margins around seventy percent, up from under forty a year ago - and the margin grew while the underlying cost per token fell, which means frontier pricing is a choice about scarcity, not a recovery of costs.7 When you pay list, you are the one doing the subsidising: gross profit on serving funds a sliver of the training bill for the next mind. What was subsidised was the flat-rate subscription - a fixed monthly fee underneath a power user is taxi economics - and that door is being closed politely but firmly; you will recall it took exactly one working prompt to max ours out. The subsidy that remains has been aimed rather than sprayed: startup credit programmes, of which our $300,000 is one, are investor money converted into named, underwritten usage. So - is it passed on to VCs? For us, literally yes, for now, by name. For the anonymous list-rate payer: no, you are the margin.
The IPO half of the question turned out to be timelier than I would like. As this is written, SpaceX prices the largest flotation in history tonight and lists tomorrow morning, with xAI folded inside it; Anthropic confidentially filed on the first of June - eight days before it shipped the model this article is about - on a $47 billion run-rate; OpenAI followed within the week. The textbook says public-market scrutiny ends subsidy and installs price floors. The tape, this very week, says otherwise: with Chinese open-weight models at a tenth to a fiftieth of frontier prices now carrying the majority of openly-routed traffic, the reporting has the labs weighing pre-IPO price cuts to lock in share before the scrutiny starts. The margins reckoning comes after the lockups, not before.
The deeper pattern is the one to plan around, and it cuts both ways. Capability at a fixed level keeps getting five to ten times cheaper per year - what cost us $1,755 in June should cost a few hundred dollars by next summer, from somebody. But the frontier task keeps getting dearer, by current estimates three to eighteen times a year, because the frontier is priced by scarcity and refilled by ambition, and agent workloads multiply tokens faster than per-token prices fall. Cheap AI is not gone. It just is never where the newest houseguest lives - and the houseguest is the reason we renovated.
// the wider board, since we did the reading
The research that fact-checked this article turned up more than the article needed, and some of it is too useful to leave in the drawer. Consider this the good-to-know section.
The enterprise caps quoted earlier look like a ceiling. They are not - they are an attribution problem wearing a ceiling's clothes. The pain threshold enterprises are actually enforcing sits at perhaps $50-100 per developer per day, which is a full order of magnitude below the fully-loaded daily cost of the engineer an agent fleet might substitute for. The constraint is not that the spend is uneconomic; it is that nobody can yet prove the substitution - the company that capped its engineers said exactly this, out loud, while seventy percent of its committed code was machine-written. The category still tripled in a year. The day someone solves ROI attribution for agentic work, the budgets that look unthinkable today will approve themselves. Our spend is not ahead of the enterprise curve; it is a preview of the curve that exists once that proof does.
On whether cheap AI is gone: the April everyone slept on is the one where four Chinese agent-grade models shipped within seventeen days, and the cheapest of them now lists at $0.435 in and $0.87 out per million tokens - twenty-three to fifty-seven times under the houseguest, with cache hits at a third of a tenth of a cent, hosted on US infrastructure so the data objection no longer carries. The majority of openly-routed traffic already runs on them. The honest catch, and it is precisely shaped like this machine's workload: the four-month capability gap concentrates in long-horizon, multi-agent orchestration - the very thing that produces $1,755 evenings - rather than in per-edit code quality. The cheap tier relieves the routine four-fifths of token volume and leaves the binding fifth exactly where it was. Renting the frontier for the hard fifth and the commodity for the rest is, fairly obviously, where this all lands.
Why frontier prices can hold scarce while everything beneath them deflates: memory. DRAM contracts rose by more than half in a single quarter this year, something like a third of Big Tech's capex is going to memory alone, and the consensus relief date is late 2027 - until then, every new unit of frontier supply arrives pre-sold to demand that grew while it was being built.
And the piece that reframes our own deadline: measured agent task-horizons are doubling every few months, the commodity tier deflates at five to ten times a year, and the genius tier refills above it on roughly an annual rhythm. Today's Fable-class capability will be available for a fraction of the price within about a year - from somebody, possibly several somebodies. Which means the 22nd was never really Fable-versus-Opus-forever. The actual question is how many months of frontier premium are worth paying while this class of capability is scarce, before stepping onto the deflating tier at the point it catches up to where we already were. A large pile of credits is not a war chest for that question. It is the arbitrage instrument.
// the decision
The 22nd is eleven days out, and we genuinely do not know yet. That is not coyness; it is the honest state of a decision whose inputs are still arriving at $200 a session.
What can be said before the day: the economics are honestly strange and we have decided to find them funny. The most expensive conversation this machine has ever had was the one where it audited itself for the new model's benefit - $1,755 of Fable 5, spent renovating the house for Fable 5, against a credit pile that makes the question affordable and a fallback wardrobe that makes it reversible. And Opus 4.8 is not a consolation prize: half the rates, most of the capability, already the second seat in our review pattern - settling onto it would be a decision, not a defeat. The machine itself no longer cares which way any of it goes. One line flips it. The profiles swap. The canary writes a different word in its log, and the only thing on the box that gets sentimental about model launches is the person typing this.
The fossils were the real lesson, and they will be true at the next launch too, whoever ships it. Nothing in the config was wrong when it was written; it was wrong by the time it was read, and there was no mechanism by which anyone would notice the transition. That is not a prompting problem. It is the oldest operations problem there is, wearing new clothes: the system drifted, and the documentation - which in this trade is also the executable - did not drift with it. Date your incantations. Version your spellbook. Keep one bird in the mine that knows what day it is. And if a brilliant, expensive lodger moves in: renovate early, measure the folklore, and keep the spare room made up.
That's the take.
A single
"model"key in the harness settings, inherited by every session that does not explicitly override it, which on this machine is all of them. The honest term for this arrangement is "single point of failure"; the affectionate term is "convenient". Both are correct, which is how single points of failure get built. The credits, for the curious, were acquired the boring way - a startup programme - and convert enthusiasm into runway at a fixed exchange rate. ↩Seventeen agents, four phases, 237 tool calls, roughly two million tokens - reading config, not writing it; the audit was read-only by design and every recommendation waited for approval. Archaeology before remediation. The midden metaphor is unfair to middens, which at least stratify in date order. ↩
The ritual had been applied so thoroughly that removing it became a project in itself: the copies in plugin-managed files get wiped and reinstated by plugin updates, so those needed counter-instructions in the profiles instead of edits in place. Fossils in rock you own can be excavated; fossils in rock that re-deposits itself monthly need a different strategy. ↩
The alternative design - swapping the instruction file itself per model via symlink - was rejected for a reason worth recording: the ordering of hook execution versus instruction-file loading is undocumented, and a mechanism that depends on undocumented ordering breaks on a harness update, silently, at 3 a.m., on a Tuesday. Context injection has documented semantics. Boring wins. ↩
The response metadata names the model that actually served the call, in a field the model itself cannot embellish. Asking "which model are you?" is a vibe check; reading
modelUsageis a measurement. The distinction between the two is most of this article. ↩Method, for the sceptical: every session transcript records per-call token usage and the model that served it. We priced each call at its model's list rates - input, output, and both cache tiers - across all sessions and their sub-agent transcripts since the model shipped: a reconstruction of the bill from first principles, made necessary because our cost-tracking tool, it turned out, was still pricing everything at the old generation's rates - its own small fossil. ↩
Sources for this section's load-bearing claims, all checked against primaries in the week of writing: the inference-margin trajectory is SemiAnalysis's reconstruction; the enterprise per-developer figures are Anthropic's own published telemetry; the Uber cap was reported on the record by TechCrunch and Fortune; the fixed-capability-falls / frontier-task-rises split is the MIT FutureTech-affiliated analysis (arXiv 2511.23455: 5-10x/year down at fixed capability, 3-18x/year up at the frontier); the pre-IPO price-cut deliberations are this week's WSJ reporting; the filing dates and valuations are from the respective announcements. A fuller research dossier with every citation sits behind this paragraph, because the only thing worse than an expensive opinion is an unsourced one. ↩