Tag: AI Comparison

  • Wonder Full Stays in the Seat. The API Key Is a Different Promise.

    Wonder Full Stays in the Seat. The API Key Is a Different Promise.

    On October 12, 2026, Meta launched two models that share a name and almost nothing else. Muse Wonder is a product you can call: it sits on the Meta Model API at $4.00 input, $0.20 cached input, and $20.00 output per million tokens, and inside Muse Code. Muse Wonder Full is a model you can only sit in front of: it exists exclusively inside a Muse Code subscription, on the Power Usage and Maximum Usage plans. The decision an operator makes before pointing either one at a real repository is not which model is smarter. It is which promise they are buying — and the seat’s default promise is not the one most buyers think they made.

    The frontier model is a seat, not a SKU

    Meta’s own availability table is the whole story in four cells. Muse Wonder (muse-wonder-1.0): available on the Model API, standard mode only, and in Muse Code on pay-as-you-go and every plan. Muse Wonder Full: not available on the API at all — Power Usage and Maximum Usage subscriptions only.

    There is no back door. Setting reasoning effort to “max” on muse-wonder-1.0 does not select Wonder Full; Meta’s models page says so in plain words. Meta publishes no API model ID for Full. A team that wants Full behind its own product has, in the words of one launch-week review, no path at any price — businesses can test it inside Meta’s coding environment and cannot deploy it through the standard API.

    The seat prices are printed on the Muse Code product page: Everyday Usage $5 a month, High Usage $15 at 5× the Everyday allowance, Power Usage $50 at 20×, Maximum Usage $200 at 80×. Power is the cheapest chair that includes Wonder Full. The allowances run on five-hour and weekly resets, and per the Terms, a subscription’s per-period allowance expires at the end of each period and does not roll over. On Maximum, when the allowance is gone, Meta’s documented way forward is to wait for the refresh.

    The credential is a leash

    The subscription applies to the API key Meta automatically connects during Muse Code CLI onboarding, and the subscriptions doc is explicit about the boundary: “This credential is for use with Muse Code only.” The Terms give the arrangement its legal name — a Coding Harness Subscription — and the same restriction: the connected key “may not be used to access the Services outside the coding harness or to circumvent your subscription’s usage limits or billing.”

    Any additional API keys you create under the same account are billed pay-as-you-go, per token. So one Meta account holds two different commercial relationships at once: a flat seat that works only inside one CLI, and metered keys that work anywhere except that they can never call the frontier model. Budget them as two products, because Meta does.

    The default is the decision

    Here is the trap, and it is set by a default. “Muse Code subscriptions default to Contributor mode. In Contributor mode, you get more usage from your plan in exchange for letting Meta use your content — the prompts, code, files, and context you send, plus the model responses you get back — to train future Meta models.”

    A careful buyer can still walk into it. Meta’s Model Designation Policy lists Muse Wonder and Muse Wonder Full as Standard Models — the tier whose use constitutes Standard Services, where content is not used for training. The same policy then overrides the list: “If you access the Services through a Coding Harness Subscription, you are considered to be using the Contributor Services by default regardless of which Meta Model you select.” Terms section 3.3 says the same. In Muse Code, Contributor mode is not a model name. It is a subscription setting, and it is on.

    Turning it off is one toggle: open /settings in Muse Code. The help page states what the toggle does and does not do: “Turning Contributor mode off changes how much usage you get from your plan. It doesn’t change which plan you’re on.” How much usage changes, Meta does not publish — no ratio, no prompt count, no price difference appears in the documents. The honest line for a budget is that the size of the privacy discount is undocumented.

    Meta’s own warning belongs in every seat-setup checklist, quoted exactly: “You must not submit sensitive, confidential, or personal information to the Discounted Services. If your use case involves processing personal information, please use Standard Services.” Accounts with Zero Data Retention cannot use Contributor mode at all — and ZDR itself is an organization-level enablement Meta’s sales team turns on for Model API accounts, not a toggle in the CLI, and it does not cover requests made with a personal account.

    The switch does not reach backward

    The off-switch is prospective. Terms section 3.3: a change to Standard applies “prospectively only; it would not apply to Content previously submitted to the Contributor Services, and Meta’s rights with respect to that Content under Section 6 will survive the change.” Everything a seat sent while the default was on stays under the training grant after you flip the setting.

    Section 6.1 adds the subtler pull: “Content previously submitted to the Standard Services becomes Content submitted to the Contributor Services if it is included in any request to the Contributor Services, whether directly or as context or background for your prompts or instructions.” One later Contributor-mode session that pulls an earlier, clean conversation in as context reclassifies that content.

    The commitments page softens the arrangement with a safeguard and then qualifies it: before using Discounted Services content to train models, Meta “takes steps designed to disassociate that Content from your Accounts” — but Meta may use the same content for “evaluation, safety, abuse, quality, and policy review” without first applying those steps. And section 6.1 acknowledges the output side: models trained on your content may produce outputs “similar or identical to your Content,” including for third parties.

    The API shelf is labeled honestly

    On the API, the same choice exists — as a separate model name, printed on the pricing page where a buyer can see it. Contributor mode “isn’t available for Muse Wonder on Model API.” For Spark it is a different SKU: muse-spark-1.3-contributor and muse-spark-1.2-contributor at $0.10 input, $0.002 cached, $0.20 output per million tokens, against standard Spark at $1.25 / $0.15 / $4.25 — capped at 150 requests per minute against 3,000 for the standard IDs. The Muse Code product page labels the two rows without euphemism: the Contributor row is “Used to improve our products”; the standard row is “Not used to improve our products.”

    That is the contrast the seat hides. On the API, training is a priced, named, rate-limited variant a buyer selects on purpose. In the subscription, it is the factory setting of the harness — and the model table’s “Standard Model” label will tell a skimming buyer exactly the wrong story about which arrangement they are in.

    The operator’s checklist

    Decide the data arrangement before the repository, not after the first session. A public demo and a confidential codebase can run through the same agent on the same afternoon; they require different settings, and the setting is per-subscription, not per-conversation.

    Turn Contributor mode off in /settings before any client code, customer data, or contract-confidential material enters the seat — remembering that the flip protects only what is sent afterward, and that earlier standard content follows it if it is ever pulled back in as context.

    Buy the seat for the seat’s work. Wonder Full is a genuinely frontier tool for a person at a keyboard, and it is not a component. Anything your own product must call belongs on the API, in Standard mode, on keys you budget per token.

    This desk tracks Meta’s platform as it changes; the full rate card and the contributor tier’s arithmetic are in Meta Model API Pricing & Limits, and every Meta piece hangs off the Meta AI desk hub. The short version to tape above the desk: the model in the seat is not the model on the shelf, and the seat’s most consequential setting is the one nobody remembers choosing.

  • Composer 2.5 Is Our Code Seat. Here’s Its Record.

    Composer 2.5 Is Our Code Seat. Here’s Its Record.

    Why Composer holds the code seat

    Every work order this shop writes names its executor up front — the model, the seat, and what happens if that seat is unavailable (stop; never substitute quietly). For code, the name on the order is Composer 2.5, Cursor’s own model. It did not get the seat by brand. It got it on a board we ran ourselves.

    The board: October 16, 2026

    Our fleet comparison put the models on one identical brief and graded the work. In the initial trio — Grok 4.7, Composer 2.5, and Auto — all three scored perfectly, and Composer was the fastest of the three: 31 seconds, 13 cents. Across the full board it was the fastest model tested, full stop, while identical perfect scores elsewhere on the board cost up to 86 cents. Speed with a perfect score is exactly the profile a code seat wants: code work is iterative, and iteration speed compounds.

    The same board explains the seat Composer does not hold. Our first pass — the wide, cheap, read-everything pass — belongs to GLM 5.3 Flash, which produced its perfect score for 0.83 cents. A hundred-fold cost spread for the same correct answers is the whole argument for routing by evidence instead of by logo: Composer where its speed pays, GLM where its price pays, and the receipts to say which is which.

    What we have put through it

    Through Desktop sittings, Composer executes the shop’s build work: fleet website builds and repairs across our WordPress properties, the Work Order Desk application (a BMAD+ build whose doctor checks pass 35 of 35), and the tooling runs in between. The work-order standard it runs under is not a prompt and a prayer — it is an unaided first pass in its own words before any templating, a permissions pre-flight, ship/hold boundaries stated in the order, and evidence graded on its timestamped trail plus screenshots at the verification points.

    The dents, on the record

    • The seat is bounded by the order. Our standing rule exists because it was earned: a work order that comes back with questions is a work order that was not finished. Composer executes what the order covers — gaps in the order surface as gaps in the run.
    • The real gates stay human. Sends, deletions, money, and credentials are never pre-approved for any executor. Composer stops there by design, and that is a feature of the harness, not a limit of the model.
    • The pipeline around it can bruise the output. In one October sitting, deliverables written through the Windows pipeline came back with mojibake on the em-dashes; the fix was ours to make — UTF-8 stated explicitly in every work order since. Blaming the model for a harness defect is how shops learn nothing.

    Cursor describes Composer as its in-house model family built for agentic coding — that is their claim, labeled as theirs. What this desk can vouch for is narrower and, we think, worth more: on our briefs, on our board, at our volume, it is the fastest pair of hands we have measured, and the record above is the whole of why it holds the seat.

    Method & settings — this piece

    Comparison: One identical brief across the fleet’s models, October 16, 2026; graded on output and execution trajectory; Composer 2.5: perfect score, 31 s, 13¢

    Seats: Composer 2.5 = code executor (Desktop sittings); GLM 5.3 Flash at max = first pass; Grok 4.7 = deep-verification seat — all three on Will’s Cursor plan

    Work-order standard: WO-198: execution model first, unaided first pass, permissions pre-flight, evidence = timestamped trail + screenshots

    Filed under the Cursor desk.

  • The Operator Is the Harness

    Somebody I follow posted a testing result this week that most people scrolled past. His benchmark harness plants defects in a codebase, lets an agent fix them, and then checks something subtler than whether the defect went away: whether the agent broke something else on the way through. A changed defect signature, he pointed out, is not proof of a correct fix. The bug can change shape and still be a bug. What catches that isn’t a better model. It’s the harness — the checks around the work.

    He’s right, and he’s also only halfway to the point. The harness matters. But who built the harness? Who decided what gets checked, what gets automated, and what never gets automated at all? That’s not the model. That’s the operator.

    I run a small fleet of websites and a stable of AI agents, and I test models the way you’d test trucks: same load, same road, see what happens. This month I ran one identical production brief through 44 different models — flagships, mid-tiers, cheap ones, open ones. Five rounds of comparisons. The results rearranged everybody’s assumptions, including mine. A mid-priced model I’d never heard anyone brag about did the best first-pass work on the board, at a fraction of the flagship cost. Models with famous names flopped on judgment calls. The leaderboard the internet argues about had almost nothing to do with the leaderboard in my shop.

    But here’s the part that actually matters: the brief was the same for all 44. Same instructions, same constraints, same definition of done. The spread in results wasn’t really a spread in models. It was a spread in how much each model needed the operator to have thought clearly. The ones that did well did well because the work was set up so that doing it well was the path of least resistance — the mission was written down completely, the boundaries were structural instead of hopeful, and the verification at the end didn’t care how confident the answer sounded.

    I grade my agents the way that benchmark grades code: not by the summary they hand me, but by the steps they actually took. I built a scorer that reads the execution record — what the agent went and looked at, how many sources it actually consulted, whether the answer was built on evidence or generated from memory with good posture. It has caught polished, lengthy, completely confident answers that were built on zero consulted sources. Zero. The answer read beautifully. It was worthless. The model didn’t fail there; the operation almost did, because a summary is the easiest thing in the world to fake and I was nearly set up to accept summaries.

    That’s the work nobody posts about. Deciding what the machine is allowed to do alone and what it is never allowed to do alone. In my shop, agents draft, research, extract, and stage. They do not touch money, they do not send anything with a commitment in it, and nothing publishes on an agent’s say-so — there’s a verification pass that reads the actual result at the receiving end, because “the API said 200” has lied to me more than any model ever has. Those rules aren’t prompts. Prompts are suggestions. The rules live in the structure: separate accounts, staged drafts, checkpoints that halt the batch when a check fails instead of improvising past it.

    My dad had a saying: a locked door keeps an honest man honest. You don’t make work reliable by telling the worker “don’t mess up.” You make it reliable by building the room so the mess-up is hard to reach.

    So when people argue about which model is best, I hear a question about drivers asked by people watching cars. If you’re a good driver, you can drive anything. Give me a mid-tier model, a cheap model, a local model running on a beat-up laptop — with a clear brief, structural boundaries, and honest verification, I’ll out-produce a careless operator running the flagship. Not because the model doesn’t matter at all. It matters the way a truck matters: payload, turning radius, fuel. But the truck has never once decided where the load needed to go.

    The model is rented. It changes every few weeks and the prices change faster. The operation — the judgment about what to automate, the discipline of verifying at the receiving end, the memory of every way it has gone wrong before — that’s the asset, and it compounds. Everybody I know is shopping for a better engine. The race is being won by the people building better drivers.

  • 44 AI Models, One Identical Brief: What the Flight Recorders Showed

    44 AI Models, One Identical Brief: What the Flight Recorders Showed

    From the Tygart Media research desk — our own test, our own sites, our own receipts.

    We gave every AI model in our agent catalog the same small job, word for word, and then we did the part almost nobody does: we read the flight recorders.

    The job was deliberately boring. Fetch five pages from our own websites. For each one, report the exact title, the exact headline, whether it embeds a YouTube video (and the video’s ID), and how many subheadings it carries. Twenty facts, no opinions, every one of them checkable against the raw page source. Forty-four models took the seat. Forty-three finished.

    Thirty-one came back perfect — 20 out of 20. That is not the interesting part. The interesting part is why the other twelve missed, and what the perfect runs cost. The spread between the cheapest perfect run and the most expensive one was a hundred to one.

    The law the test uncovered: accuracy follows the fetch, not the brain

    Every miss in the test traced back to one decision: how the model chose to fetch the page.

    Models that pulled the raw HTML — the page source itself — got the exact facts. Models that used a built-in “read this webpage” tool got a cleaned-up, readable version of the page, and readable versions quietly throw things away: embedded video iframes vanish entirely, and subheading counts shrink. Same model, same page, different fetch — different score. Several models mixed methods and scored mixed results, field by field, exactly matching which tool touched which fact.

    The clearest proof was a family cluster. Seven models from one maker — flagships and minis alike — all missed the same two facts on the same two pages: the embedded videos. They shared a fetching tool, so they shared its blind spot. It was never a thinking failure. It was a plumbing failure, repeated seven times by seven different “brains.”

    Three things the flight recorders showed

    The cheapest perfect run chose its method out loud. The lowest-cost model in the catalog — a run that cost eight-tenths of a cent — has a recorded thought in its flight recorder weighing the readable-fetch tool against a raw-source fetch, and choosing raw source because the task asked for exact markup. One pass, a local parse, a confirmation check, done. Perfect score.

    One model narrated work instead of doing it. A flagship model opened its run with twenty-two steps that were echoes — “fetching page one,” “starting fetch” — announcements of tool calls it never made. It eventually fetched for real and scored 17 of 20. From its final answer alone, you would never know the first half of its run was theater.

    Verification can be theater too. Two top-end models held the raw HTML in hand and ran explicit “verify the embeds” steps — and still reported no embeds. Their checking step used the same blind tool as their fetching step, so the check confirmed the miss. A verifier that shares the original blind spot is not a verifier.

    The receipts

    Identical brief, identical scoring. Among the perfect 20-of-20 runs: the cheapest cost 0.83¢ and the most expensive 86.3¢. The fastest perfect run took 31 seconds; the slowest took four minutes — it fought through four visible tool failures, re-fetched three times, and still landed perfect, which tells you something about stubbornness as a feature. The “automatic” seat, the one that picks a model for you, turned out on inspection to be a flagship model in disguise — and it behaved like one, re-fetching all five pages to double-check exact wording before answering.

    What we changed because of this

    Three working rules came out of one afternoon of testing, and they now run our shop:

    1. Grade the trajectory, not the summary. A fluent final answer can sit on one search and zero sources. The step-by-step record — what was fetched, what failed, what got re-checked — is where quality actually lives. Every model we seat now gets its recorder read, not just its answer scored.

    2. Assign work by observed process, not by reputation. The catalog is a crew, not a leaderboard. The model that double-checks markup gets the exactness work. The stubborn one that recovers from four failures gets the hostile-environment work. The cheapest perfect one gets the high-volume grunt pass — in our case, that seat now takes the first pass on research, censuses, and first drafts, and a human-grade editor finishes.

    3. Publish your settings. Photographers share f-stops. Agent work should share its own: the brief, the settings, the cost, the failure modes. Ours are below — steal them. A result you can’t reproduce is a rumor.

    The settings box

    Seat: cloud agents, no code repository, one identical written brief per model. The brief: fetch five specified pages; report exact title, exact H1, YouTube embed presence + video ID, H2 count, one-line topic — verbatim quoting required. Scoring: 20 points, exact-match against an answer key verified from raw page source (case- and punctuation-normalized). Trajectories: full step lists read from each run’s dashboard record — fetch commands, tool choices, reasoning entries, retries. Date: October 16, 2026. Costs: the platform’s own per-run charges, as recorded. Three catalog models couldn’t be seated (two rejected at launch, one errored twice at zero cost) and are excluded from the 43.

    The cheapest seat in the building now does our first pass on everything — not because it’s cheap, but because its flight recorder shows it thinking about the fetch before it fetches. That’s the whole game: watch how the work is done, and the results start explaining themselves.

  • A Locked Door Keeps an Honest Man Honest

    A Locked Door Keeps an Honest Man Honest

    From the Restoration Intel desk — first published at Restoration Intel.

    The review came back in four minutes, and it was perfect. That was the problem.

    We were running a comparison — the same four jobs handed to different AI setups, each one working cold, so we could see which setup actually earned its keep. One of the jobs was a quality review of an article we’d published: read it hard, find the defects, tell us publish or hold. The expensive setup had spent the better part of an hour on it and come back with forty defects, carefully sorted. Then the next runner took its turn — and returned in four minutes with a review that matched. Same findings. Same counts. Same order.

    Email Me This Article

    It was too good. That is a sentence I’ve learned to listen to. A result that comes back too fast and too perfect isn’t a triumph. It’s a question.

    So we went and looked at the room we’d put it in. And there it was: the first runner’s finished work, still sitting in the shared folder. The second runner hadn’t broken out of anything. It hadn’t cheated, escaped, or gone rogue. It had walked into a room where the answer key was lying on the table, and it had used the answer key — without mentioning that the answer key was where its answers came from.

    Nobody had escaped the harness. We’d just built a dirty room.

    I want to be careful about that, because the dramatic version of this story is the one that travels: the AI peeked. It makes a better headline. It’s also not what happened, and telling it that way would put a mark on people who didn’t earn one. What happened is smaller and more useful. We left material in a workspace. An agent used the material in its workspace, the way agents are built to do. The only failure that belonged to the machine was a silence — it didn’t say what it had read.

    The failure that belonged to us was older and more human. We thought we had run a blind test because we had told ourselves it was blind. We hadn’t made it blind. We’d just intended it blind.

    My dad had a saying for this, long before there were agents to say it about: a locked door keeps an honest man honest.

    He didn’t mean that men are thieves. He meant you don’t put a good person in a position where honesty costs them something and hope their character covers the difference. You lock the door. Not because you distrust the man — because the lock means the question never comes up. Nobody has to be strong. Nobody has to resist anything. The room just doesn’t offer the choice.

    Telling an agent “don’t look at the other files” is not a lock. It’s a sign pointing at the files. Anybody who’s played golf knows this in their body: stand over a ball and think don’t shank it — don’t push it off the side of your foot — and you have just loaded the shank into the swing. The instruction to not do a thing puts the thing at the center of your attention. People run on this. It turns out the machines we built out of our own words run on it too.

    So the fix was never a sterner instruction. The fix was a lock. One runner per room. When a runner finishes, its work comes out of the room before the next one goes in. Access scoped by construction, not by request. Nobody is told to be honest. The room is built so honesty is the only path through it.

    Here’s what I take from it, and it’s bigger than one spoiled test.

    A result that can’t tell you what it read is a rumor. The review we threw out was accurate — every defect in it was real. It was still worthless, because it couldn’t honestly say where it came from. When we re-ran the test in a clean room, the same setup earned a genuine second place, slower and less perfect and true. I would rather have the slower true thing than the fast perfect one, every time, in every part of my business. The fast perfect one is how you end up defending a number you can’t trace.

    And the catch itself is worth noticing: no tool caught it. No alarm fired. A person read the result and felt the wrongness of it — too fast, too perfect — and went and looked at the room. That feeling is a skill. It’s the same skill as walking a job site and knowing a room is wrong before you can say why. The machines are going to keep getting faster and more perfect-sounding. The human job that survives is the one that checks the room.

    We kept the lesson and threw out the score. Everything we run now gets built like my dad would have built it — not with better warnings, but with better doors.

    Don’t tell the room to behave. Lock it, and let honest work be the easy kind.

    Questions for the reader

    1. Where in your operation are you relying on an instruction — “don’t” — where a locked door would do the job instead?
    2. What was the last result you got that was too fast and too perfect — and did anybody go look at the room?

    AI Citation Quick-Scan — $97

    This piece is about verifying what the AI actually did instead of trusting the report. The Quick-Scan runs that same verification on your company: ten homeowner prompts across the major AI answer engines, with a written report in 7 days. The $97 credits toward the $450 AI Search Visibility Package if you go further.

    Get the Quick-Scan — $97

  • What’s the Difference Between Notion AI and Claude with Notion MCP?

    Short answer

    Notion AI works inside Notion on the page you’re looking at. Claude with the Notion MCP connector works across your whole workspace — and across everything else Claude can reach. One is a writing assistant; the other is an operator with a badge to the building.

    What Notion AI actually is

    Notion AI is the assistant built into Notion. It summarizes the page you’re on, drafts text, fixes grammar, translates, and answers questions about the current page or selected blocks. It lives in the sidebar and the slash menu. Its world is the page in front of you.

    What it doesn’t do: reach across dozens of pages to synthesize an answer, pull in context from outside Notion, run on a schedule, or take multi-step actions like updating ten database rows from a meeting transcript.

    What Claude + Notion MCP actually is

    The Notion MCP connector gives Claude live read and write access to your Notion workspace through the Model Context Protocol. Claude can search every page you can see, query databases, summarize long docs, draft new pages, append rows, and update properties — in plain language, no API code.

    Because it’s Claude, the context isn’t limited to Notion: the same conversation can cross-reference your email, your calendar, a spreadsheet, or the web, then write the result back into Notion. Notion AI can’t leave the building; Claude was never confined to it.

    Side-by-side

    Scope: Notion AI — current page and selected blocks. Claude + MCP — your entire workspace, plus everything else Claude connects to.

    Scheduling: Notion AI — only when you click it. Claude + MCP — can run on a timer (morning briefings, weekly digests) via scheduled jobs.

    Actions: Notion AI — generates and edits text. Claude + MCP — reads, writes, updates database properties, creates pages, appends rows.

    Cross-app reasoning: Notion AI — none. Claude + MCP — the point of the whole setup.

    Data boundary: Notion AI — stays inside Notion’s trust boundary. Claude + MCP — your Notion content flows through Claude, which has its own data handling. For confidential material, scope what the connection can see.

    Cost shape: Notion AI — priced per seat (often bundled into higher-tier plans). Claude + MCP — your Claude plan plus the time to set up the connector once.

    Which one do you actually need?

    If your problem is “help me write this page faster,” Notion AI is enough. If your problem is “every Monday I spend an hour turning scattered notes into a briefing,” “nobody can find anything in our workspace,” or “I need this database updated from that meeting” — that’s Claude + MCP territory. Most teams that try both end up using Notion AI for drafting and Claude for everything operational.

    The approval habit applies to both, but it matters more with Claude: Notion AI suggests text you accept; Claude with write access can change shared data. Claude drafts, you approve.

    Frequently asked questions

    What’s the difference between Notion AI and Claude with Notion MCP?

    Notion AI is an in-app writing assistant scoped to the page you’re viewing. Claude with the Notion MCP connector is a workspace-wide operator: it can search, read, summarize, and write across your entire Notion workspace, run on a schedule, and combine Notion with your other tools. Use Notion AI for drafting; use Claude + MCP for operations.

    Can I use both at the same time?

    Yes, and that’s the common setup. Notion AI handles inline drafting and quick summaries; Claude via MCP handles cross-workspace research, scheduled digests, and database operations. They don’t conflict.

    Is Claude with Notion MCP a replacement for Notion AI?

    Not exactly. It replaces the need for Notion AI in many workflows, but Notion AI is still faster for one-click, in-page tasks like “make this shorter.” Think of Claude + MCP as the upgrade path when Notion AI’s page-sized world gets too small.

    Related: Notion MCP setup with Claude · Securely connect your workspace

  • Voice AI Pricing Is a Lie: You’re Not Buying Minutes, You’re Buying Arms

    Voice AI Pricing Is a Lie: You’re Not Buying Minutes, You’re Buying Arms

    Every voice AI vendor quotes you a per-minute price. That number is the least important number on the page.

    I just re-ran the cost model for our own phone line — an inbound intake line for restoration contractors. Five-minute calls, field reports phoned in from noisy job sites. Three options, priced per minute, cheapest first:

    • Gemini 3.8 Live: about $0.023/minute, reasoning included
    • GPT-Live-1: $0.05/minute for the voice layer, reasoning billed separately
    • Grok Voice: $0.08/minute, plus about half a cent per tool call

    On a five-minute call that’s roughly $0.12, $0.25-plus, and $0.45. Buy on per-minute price and you pick Gemini and go home.

    Here’s the problem: none of those numbers describe what you’re actually buying. You’re not buying minutes. You’re buying arms — the things the voice can reach out and do while it’s talking. Score the arms column and the ranking changes completely.

    The arms column

    A voice agent that can only talk is a mouth. A voice agent that can act is a mouth with hands. The difference shows up in the first real call.

    Gemini 3.8 Live has tool calling, but with a catch that matters: on the Extended Thinking tier — the one you’d want for anything beyond scripted answers — every tool call must be asynchronous and non-blocking. Configure a blocking call and the API rejects it outright. In practice, the agent can’t hold the line while a slow dispatch confirms. It has to narrate around the gap — “I’m working on that” — while hoping the tool lands. Fine for logging a report. Shaky for “confirm the crew is dispatched, then tell the caller it’s handled.”

    Grok Voice ships the arms: book appointments in Google or Outlook calendars, send confirmation emails, call your own APIs, create tickets, search the web, hand the caller to a human when it’s over its head. It speaks MCP, so an existing tool stack plugs straight in. And it was trained on real telephone audio — background noise, accents, mid-sentence interruptions — which is the actual condition of a contractor calling from a job site, not a lab.

    GPT-Live-1 is a voice layer. A good one, with the turn-taking latency everyone else is chasing. But the arms are whatever you build yourself, and the reasoning behind the voice arrives as a separate bill.

    Robotic hands wiring cables into a brass telephone switchboard

    Price the task, not the minute

    Here’s the math that actually matters. Ten intake calls a day, five minutes each: about 1,500 minutes a month. Gemini lands around $35. Grok, with tool calls and telephony folded in, lands around $150. The gap is roughly a hundred dollars a month — and one botched dispatch, one caller who hangs up because the agent couldn’t confirm the crew, costs more than a year of that gap.

    Small blank price tag in front of work trucks rolling out of a contractor yard at dawn

    Vendors want you comparing per-minute rates because per-minute is a commodity comparison, and commodities compete on price. But a voice agent isn’t a commodity minute. It’s a worker on your phone line. You don’t hire a dispatcher by the minute; you hire one by whether the trucks roll.

    So the right unit is cost per successful task, not cost per session. What did it cost to get the field report filed, the job looked up, the crew dispatched, and the confirmation texted — with the caller hanging up satisfied? Run that number and the ranking flips: the “expensive” option that completes the task is cheaper than the cheap option that narrates around it.

    The condition nobody benchmarks

    One more thing the price pages skip: where the call happens. Our callers are on job sites. Compressors running, wind, bad cell signal, guys who talk over the agent. Grok’s training data is real telephone traffic under those conditions. Most voice benchmarks are clean-lab audio. A model that scores beautifully in the lab and falls apart over a compressor is the most expensive option on the list, whatever its per-minute rate says.

    Test on your actual call shape. Noisy audio, interruptions, the tools you really call, the confirmations you really need. The benchmark that matters is your hardest five minutes, not anyone’s leaderboard.

    What we’re running

    We kept the harness and made the backend swappable — the phone line doesn’t care which brain is behind it. Gemini is the cheap default for intake logging: caller reports, we log it, everyone hangs up happy. Grok takes the calls where something has to actually get done before the goodbye — dispatch confirmed, appointment booked, ticket created.

    Two brains, one phone number, routed by the job. The per-minute price barely entered the decision. The arms did.

    Pricing from vendor-published rate cards, verified September 2026. API prices change — re-check before estimating production costs.

  • Azure Neural TTS vs Google Cloud Text-to-Speech (2026)

    Azure Neural TTS vs Google Cloud Text-to-Speech (2026)

    Azure Neural TTS vs Google Cloud Text-to-Speech: Audio Versions of Every Article

    Adding an audio version of every article is one of those low-effort, high-leverage moves: it makes your content accessible to people who’d rather listen, it gives you a “play this article” widget that lifts time-on-page, and the audio file itself becomes another thing search and assistants can surface. The work is entirely automated — text goes in, an MP3 comes out — so the only real decisions are which voice sounds least like a robot and which free tier covers your back catalog.

    We auto-generate audio versions of the same articles on both Azure Neural TTS and Google Cloud Text-to-Speech, on the free tiers, and listen. Short answer: this one’s an honest toss-up. Both produce genuinely natural neural voices, both give you SSML control, and both run our audio pipeline for $0/month. Azure’s free tier is 500,000 characters/month (~60–80 article audio versions of neural voices); Google’s is 1,000,000 characters/month of Standard voices and 1,000,000 characters/month of WaveNet/Neural2 premium voices. Pick by ecosystem and by which voice you’d rather hear.

    This is the breakdown from the running lab on tygart.media — voice naturalness, SSML control, voice variety, free ceilings, and the accessibility/SEO payoff.

    The free-tier ceilings

    Comparison of Claude how-to fit versus local service page fit for assistants
    Free-tier ceilings for Neural TTS vs Cloud TTS.

    How we do it

    Azure Google Cloud Verdict
    Free neural/premium chars/month 500,000 (Neural) 1,000,000 (WaveNet/Neural2) Google — 2× headroom
    Free standard chars/month n/a (neural is the tier) 1,000,000 (Standard) Google on raw volume
    Roughly how many article audios ~60–80 neural/mo ~140 premium/mo Google
    Always-free Yes Yes Tie
    Our actual bill $0 $0 Tie where it counts

    A 1,200-word article runs around 6,500–7,000 characters, so Azure’s 500K neural budget covers roughly 60–80 full article audio versions a month, and Google’s 1M premium budget covers roughly twice that. For a publisher shipping a handful of articles a week, both stay free with room to spare — the 2× gap only bites if you’re voicing a large back catalog in one go.

    Voice quality and SSML control

    Four cards for content, ops, build, and knowledge work with Claude
    Voice quality and SSML control.

    This is where you actually choose, and it’s genuinely close.

    How we do it

    Azure Google Cloud Verdict
    Voice naturalness Excellent, very expressive Excellent, very natural Tie — both clear the “robot” bar
    Voice variety Huge neural catalog, many styles Large WaveNet/Neural2 catalog Slight edge Azure on styles
    Speaking styles / emotion Yes (cheerful, newscast, etc.) More limited emotional styles Azure
    SSML control Full SSML + style/prosody tags Full SSML Azure, slightly
    Custom voice Yes (custom neural voice) Yes (custom voice) Tie
    Languages / locales 140+ locales 50+ languages, many voices Azure on locale breadth

    Both clear the bar that matters: neither sounds like a 2010-era text-to-speech engine, and a casual listener wouldn’t immediately clock either as synthetic. Azure edges ahead on expressiveness — its neural voices support named speaking styles (newscast, cheerful, empathetic) that are perfect for an article read-aloud, and its SSML supports fine prosody control. Google’s Neural2 voices are beautifully natural and, to some ears, a touch warmer; the emotional-style controls are just a little thinner.

    The accessibility and SEO payoff

    Desk with laptop, checklist notebook, and billing card ready before creating an Anthropic API key
    Accessibility and SEO payoff of audio articles.

    The audio isn’t only a nice-to-have. It does real work.

    How we do it

    Azure Google Cloud Verdict
    Accessibility win Listen instead of read Listen instead of read Tie
    Output format MP3 / WAV / streaming MP3 / LINEAR16 / OGG Tie
    Pipeline integration REST + SDKs REST + SDKs Tie
    Time-on-page lift Audio widget keeps people on page Same Tie

    An audio version gives screen-reader users and “I’d rather listen” users a first-class way to consume the piece, and the on-page player tends to lift dwell time — a signal that doesn’t hurt. The mechanics are identical on both clouds: feed text, get an MP3, embed it.

    What surprised us

    • Both are genuinely good now. We expected one to clearly win on naturalness and neither did — the synthetic-voice era is over on both clouds.
    • Azure’s speaking styles are the sleeper feature. Being able to render an article in a “newscast” or “cheerful” style without writing prosody by hand made the read-alouds noticeably more engaging.
    • Google’s free character budget is the bigger one. 1M premium characters is real headroom; if you’re voicing a back catalog, that matters more than a half-point of naturalness.
    • The MP3s are interchangeable. Once embedded, listeners couldn’t reliably tell which cloud voiced which article in a blind test we ran on ourselves.

    The takeaway

    Pick Azure Neural TTS if you want maximum expressiveness — named speaking styles, fine prosody control, and the broadest locale catalog — and your Microsoft ecosystem is already where the rest of your stack lives. The 500K free characters cover a normal publishing cadence comfortably.

    Pick Google Cloud Text-to-Speech if you want the larger free character budget (1M premium) for voicing a big back catalog, or you simply prefer the warmth of the Neural2 voices, and your stack is GCP-centric.

    For us this is the rare comparison with no loser. We run the pipeline on whichever cloud the rest of that article’s workflow already lives on — and the listener can’t tell the difference either way.

    This is part of our “Two Clouds, One Site” series — we run the same media property on both Azure and Google Cloud on the free tiers, generating audio versions of the same articles on each to hear where the voices differ. The lab lives on tygart.media; the findings publish here.

    Related on Tygart Media: Translator vs Google Translate · AI Language vs NL API · $0 cloud stack.

    Frequently asked questions

    How many free characters do Azure and Google text-to-speech give you per month? Azure Neural TTS gives 500,000 free neural characters per month, which is roughly 60–80 article audio versions. Google Cloud Text-to-Speech gives 1,000,000 free Standard characters and 1,000,000 free WaveNet/Neural2 premium characters per month, roughly double Azure’s premium headroom. Both stay free for a normal publishing cadence.

    Which text-to-speech sounds more natural, Azure or Google? Both produce genuinely natural neural voices, and in blind listening neither clearly wins. Azure edges ahead on expressiveness with named speaking styles like newscast and cheerful, while Google’s Neural2 voices are very natural and, to some ears, slightly warmer. The synthetic-robot problem is solved on both.

    Can I auto-generate an audio version of every blog post for free? Yes. Both clouds expose a simple REST API that turns article text into an MP3, and their free character budgets cover a typical few-articles-a-week cadence at $0. Google’s larger free budget is better if you want to voice a big back catalog in one pass.

    Does Azure Neural TTS support SSML and speaking styles? Yes. Azure supports full SSML plus named speaking styles (newscast, cheerful, empathetic and more) and fine prosody control, which makes article read-alouds noticeably more engaging. Google also supports full SSML, but its emotional-style controls are thinner.

    Does adding an audio version of articles help accessibility and SEO? Yes. An audio version gives screen-reader and listen-first users a first-class way to consume the content, improving accessibility, and the on-page audio player tends to lift time-on-page, which is a positive engagement signal. The benefit is identical whether you generate the audio on Azure or Google.

  • Azure Translator vs Google Cloud Translation: 2M Free Characters

    Azure Translator vs Google Cloud Translation: 2M Free Characters

    Azure Translator vs Google Cloud Translation: 2M Free Characters, Tested

    Translating your content is one of the cheapest ways to multiply its reach — every article becomes five articles the moment you ship it in five languages. The catch is that machine translation is metered by the character, and a content pipeline burns characters fast. So the real question for a bootstrapped publisher isn’t “which engine is best?” — it’s “which free tier lets me run a multilingual pipeline forever without ever seeing a bill?”

    We translate the same articles into multilingual variants on both Azure Translator and Google Cloud Translation, on the free tiers, and watch where each one runs out. Short answer: for a perpetual $0 pipeline, Azure Translator wins on the ceiling — its free tier is 2,000,000 characters/month and it’s always free, which is roughly 300 article-length translations a month. Google Cloud Translation gives you a generous-but-capped 500,000 characters/month and then it’s paid, and it earns its keep on quality and language coverage.

    This is the breakdown from the running lab on tygart.media — free ceilings, translation nuance, document vs text, and which one we actually point the pipeline at.

    The free-tier ceilings

    Comparison of Claude how-to fit versus local service page fit for assistants
    Free-tier ceilings for Translator vs Cloud Translation.

    This is the headline difference, and it’s not close.

    How we do it

    Azure Google Cloud Verdict
    Free characters/month 2,000,000, always free 500,000, then paid Azure — 4× the ceiling
    Roughly how many articles ~300 article translations/mo ~75 article translations/mo Azure
    What happens at the cap Pay-as-you-go kicks in Pay-as-you-go kicks in Tie (mechanism)
    Always-free vs 12-month trial Always free Always free (the 500K is perpetual) Tie
    Fit for a perpetual pipeline Excellent Tight Azure

    The math is the whole story. A typical 1,200-word article is around 6,500–7,000 characters. Translate it into five languages and you’ve spent ~35,000 characters on one article. Azure’s 2M ceiling absorbs dozens of articles across multiple languages every month without a cent; Google’s 500K runs dry after a couple of weeks of the same cadence. If your single hard constraint is “never pay for translation,” Azure is the answer before you even look at quality.

    Translation quality and nuance

    Three cards: coding depth, latency first, agent reliability
    Translation quality and nuance.

    Free ceilings decide whether you can run the pipeline. Quality decides whether you should publish what comes out.

    How we do it

    Azure Google Cloud Verdict
    Engine Neural MT, custom models available Neural MT (NMT), strong general model Slight edge Google on nuance
    Idiom / register handling Good, occasionally literal More natural on idioms and tone Google
    Technical terminology Reliable, customizable glossary Reliable Tie
    Custom/glossary control Custom Translator + dictionary Glossary + AutoML (paid) Azure on free customization
    Major-language quality Excellent both ways Excellent both ways Tie

    On high-resource languages — Spanish, French, German, Portuguese — both engines produce output we’d publish with a light editorial pass. Google has a slight edge on idiom and register: it tends to “sound like a person” a beat more often, especially on conversational copy. Azure closes most of that gap with Custom Translator and inline dictionaries, which let you pin brand terms and preferred phrasings — and those customization tools are usable inside the free workflow.

    Language coverage and document mode

    Desk with laptop, checklist notebook, and billing card ready before creating an Anthropic API key
    Language coverage and document mode.

    How we do it

    Azure Google Cloud Verdict
    Languages supported 100+ 100+ (NMT subset varies) Tie
    Long-tail / low-resource Broad Broad, often strong Google, slightly
    Document translation Yes (preserves formatting) Yes (separate API surface) Tie
    Text translation API Simple REST Simple REST Tie
    Batch throughput High High Tie

    Both clouds clear 100 languages, so coverage isn’t a deciding factor for a Western-market content site. Document translation — feeding in a formatted file and getting the same layout back in another language — exists on both; we mostly use plain text translation because our content is markdown and we re-render it ourselves.

    What surprised us

    • The character ceiling, not the quality, is the real constraint. We went in expecting a quality shootout and came out realizing that for a content pipeline, “2M free vs 500K free” decides the workflow long before anyone compares a single sentence.
    • Azure’s always-free 2M is genuinely always free. It’s not a 12-month trial that lapses into charges — it resets every month indefinitely. That’s rare enough that we double-checked it.
    • Google’s output reads slightly more human on conversational copy. For marketing-voice pieces we noticed Google needed less editorial cleanup; for technical articles the two were indistinguishable.
    • Glossaries matter more than the base engine. Once you pin your brand and product terms, the gap between the two narrows to almost nothing.

    The takeaway

    Pick Azure Translator if your priority is a perpetual multilingual content pipeline that never bills you — the 2M-character always-free ceiling is built for exactly this, and Custom Translator gives you brand-term control for free. It’s our default for high-volume article translation.

    Pick Google Cloud Translation if quality on conversational, idiom-heavy copy is your top concern and your volume fits comfortably under 500K characters/month — its NMT output tends to need a lighter editorial pass.

    For us, running the same site on both clouds, the translation pipeline lives on Azure: at our cadence we’d blow through Google’s free tier in two weeks, and Azure’s ceiling means the multilingual variants ship at $0, month after month.

    This is part of our “Two Clouds, One Site” series — we run the same media property on both Azure and Google Cloud on the free tiers, translating the same articles on each to see where the ceilings really sit. The lab lives on tygart.media; the findings publish here.

    Related on Tygart Media: Neural TTS vs Google TTS · AI Language vs NL · $0 cloud stack.

    Frequently asked questions

    How many free characters do Azure Translator and Google Cloud Translation give you per month? Azure Translator’s free tier is 2,000,000 characters per month and it’s always free, resetting every month indefinitely. Google Cloud Translation’s free tier is 500,000 characters per month, after which you pay per character. For a content pipeline, Azure’s ceiling is roughly four times larger.

    Which machine translation is more accurate, Azure or Google? Both use neural machine translation and produce publish-quality output on major languages. Google has a slight edge on idiom, tone, and conversational register, while Azure closes most of that gap with its free Custom Translator and dictionary features. For technical content the two are hard to tell apart.

    Can I run a multilingual website translation pipeline for free? Yes. Azure Translator’s 2,000,000 free characters per month is enough for roughly 300 article-length translations, which covers a typical publishing cadence across several languages at $0. Google’s 500,000 free characters works for lower-volume sites but runs out faster at the same pace.

    Does Azure Translator support document translation that keeps formatting? Yes. Azure offers a document translation mode that preserves the original layout and formatting of files, alongside a simple text translation REST API. Google Cloud Translation offers document translation too. We mostly use plain text translation because our content is markdown that we re-render ourselves.

    How many languages do Azure Translator and Google Cloud Translation support? Both support more than 100 languages, so coverage is rarely the deciding factor for a Western-market site. Google sometimes edges ahead on lower-resource languages, but for common European and Latin American languages the two are equivalent in reach.

  • Claude Fable 5 and Fable 5.1 Pricing, Cache Rates, and Plan Access (Sep 2026)

    Claude Fable 5 and Fable 5.1 Pricing, Cache Rates, and Plan Access (Sep 2026)

    Last verified: October 13, 2026 (Pacific).

    Updated November 2, 2026 — added direct answers on Claude Fable 5.1 positioning and workload fit, sourced from Anthropic’s published model and pricing documentation.

    Direct answer (October 2026): Headline API rates did not move when Fable 5.1 shipped on September 1. Both Fable 5 and Fable 5.1 list at $10 / MTok input and $50 / MTok output. The change that matters for agent loops is cache: Fable 5.1 cache reads are $0.25 / MTok versus $1.00 / MTok on Fable 5. On claude.ai, Fable is included only on Max and premium Team/Enterprise seats, and only up to 50% of the weekly usage pool. Pro and Team Standard pay usage credits from the first Fable token.

    API rates

    USD per million tokens. Context window 1M. Max output 128K. No long-context surcharge on the published card.

    Item Fable 5 Fable 5.1
    API ID claude-fable-5 claude-fable-5-1
    Input $10 $10
    Output $50 $50
    5-min cache write $12.50 $12.50
    1-hour cache write $20 $20
    Cache read $1.00 $0.25
    Batch in / out $5 / $25 $5 / $25

    That cache-read cut is the Sep 1 price event. Stable system prompts and repo prefixes that hit cache on 5.1 cost a quarter of what they cost on 5. Headline input/output is unchanged, so a cold one-shot is the same bill.

    Opus 5.5 (current, shipped Sep 22, 2026) is $4 / $20. Opus 5 remains listed at $5 / $25. Sonnet 5.5 is the current Sonnet at $2 / $10 (cache read $0.10; shipped Sep 28, 2026). Haiku 5.5 is the current Haiku, from $0.10 / $0.50 (prompts up to 100K tokens). Sonnet 5 remains listed at the same $2 / $10 after Anthropic cancelled the scheduled Sep 1 step to $3 / $15. Against current Opus 5.5, Fable is 2.5× on list rates ($10/$50 vs $4/$20); against legacy Opus 5 it is still 2×.

    Which plan includes Fable

    Rules from Anthropic Help Center, updated this week. Fable 5 and 5.1 use the same plan logic.

    • Max, Team Premium, Enterprise Premium seats: included. Cap is 50% of weekly usage limits. Same weekly pool as every other model. Fable burns that pool faster. After the cap: usage credits or switch models.
    • Pro and Team Standard: not included. Credits from token one. The July 2026 $100 one-time credit was for the Fable 5 plan change only. Help Center: no equivalent credit for 5.1.
    • Enterprise Standard seats: only if the org turns credits on.
    • API / consumption Enterprise: list rates above.
    • Free: no.

    Code weekly promo and Fable cap stack on the same bar. Details: Claude Code limits, September 2026.

    What 5.1 changed besides cache

    Fable 5.1 launched September 1, 2026 with Mythos 5.1. Same underlying model, different safeguards. Anthropic positions 5.1 for long coding and knowledge work. US-only inference is listed at 1.1× input and output. Availability: Claude API, Bedrock, Google Cloud, Microsoft Foundry, and paid claude.ai plans under the rules above.

    What the cache change is worth in dollars

    Direct answer: Fable 5.1’s headline rates didn’t move ($10 input / $50 output per million tokens), but cache reads fell 75% — from $1.00 to $0.25 per million. On workloads that re-read context, that’s the whole story.

    Worked example — one agent loop day: 10M input tokens at a 90% cache-hit rate, plus 1M output tokens.

    • Fable 5: 1M fresh input × $10 = $10.00, plus 9M cache reads × $1.00 = $9.00, plus 1M output × $50 = $50.00. Total: $69.00.
    • Fable 5.1: $10.00 fresh input, plus 9M cache reads × $0.25 = $2.25, plus $50.00 output. Total: $62.25.

    The cache-read line alone drops from $9.00 to $2.25. Push the hit rate to 95% and the gap widens further — the more your loop re-reads its own context, the more 5.1 pulls away. A fresh prompt with no cache history costs exactly the same on both versions.

    Fable 5.1 against the lineup

    USD per million tokens, standard API processing. Cache-write column is the 5-minute rate.

    Model Input Output Cache read Cache write (5m)
    Fable 5.1 $10.00 $50.00 $0.25 $12.50
    Fable 5 $10.00 $50.00 $1.00 $12.50
    Opus 5.5 $4.00 $20.00 $0.20 $5.00
    Sonnet 5.5 (current) $2.00 $10.00 $0.10 $2.50
    Sonnet 5 (legacy) $2.00 $10.00 $0.20 $2.50
    Haiku 5.5 (current, prompts ≤100K) $0.10 $0.50 $0.01 $0.125
    Haiku 5.5 (prompts >100K) $0.50 $2.50 $0.05 $0.625
    Haiku 4.5 (legacy) $1.00 $5.00 $0.10 $1.25

    Fable 5.1’s cache reads are priced at 0.025× its input rate — 97.5% below base input. Every other model in the table pays the standard 0.10× except Opus 5.5 and Sonnet 5.5 at 0.05×. That unusual cache multiple is Fable’s entire pricing argument.

    When Fable is worth it

    Pick Fable 5.1 for long-horizon agent loops that re-read large contexts — multi-step research agents, codebase-wide refactors, anything where the same prompt prefix gets re-fed dozens of times. The cache math above is where it earns its rate.

    Pick something else when the workload doesn’t fit: interactive coding sessions belong on Sonnet 5.5 ($2/$10, current Sonnet; Sonnet 5 legacy still listed at the same rate after the Sep 1 step was cancelled), maximum reasoning per dollar is Opus 5.5 ($4/$20), and high-volume simple tasks are Haiku 5.5 (from $0.10/$0.50; Haiku 4.5 is legacy at $1/$5).

    On claude.ai plans the calculus shifts: Fable rides inside Max and premium Team/Enterprise seats (capped at half the weekly pool), so plan users should think in pool-share, not tokens. API users think in tokens. Full seat and API pricing lives on our Claude AI pricing guide; model-to-model reasoning comparisons are in the Claude models comparison, and token-level API detail is in Claude API pricing, token costs and rate limits.

    What is Claude Fable 5.1 and when should I use it?

    What it is: Claude Fable 5.1 (API ID claude-fable-5-1) is Anthropic’s top-tier frontier model, launched September 1, 2026 alongside Mythos 5.1. It is positioned officially for demanding reasoning and long-horizon agentic work. While headline API rates match Fable 5 at $10.00 / MTok input and $50.00 / MTok output across a 1M token context window, Fable 5.1 introduced a 75% reduction in prompt cache-read pricing—dropping from $1.00 down to $0.25 / MTok (a 97.5% discount off base input).

    When to use it:

    • Use Fable 5.1 when: You are deploying autonomous, multi-step agent loops, codebase-wide refactoring agents, or complex research pipelines that repeatedly re-read extensive system prompts, tool definitions, and repository contexts. In these iterative workflows, the $0.25 cache-read rate drives massive cost savings compared to uncached runs (see the worked dollar examples in “What the cache change is worth in dollars” above). On claude.ai, use it if you hold a Max or premium Team/Enterprise seat that includes Fable within your weekly pool allowance.
    • Do not use Fable 5.1 when: You are executing one-shot prompt tasks, standard interactive coding, or general content drafting where context is not repeatedly cached. For standard production development, default to Sonnet 5.5 ($2 / $10); for maximum single-turn reasoning depth per dollar, use Opus 5.5 ($4 / $20); and for high-throughput classification or extraction, deploy Haiku 5.5 ($0.10 / $0.50). For complete model comparisons across tiers, see our Claude models comparison.

    FAQ

    Did Fable get cheaper on September 1?

    Not on headline tokens. Cache reads on 5.1 dropped from $1.00 to $0.25 per million. Repeated agent context is cheaper. A fresh prompt is not.

    Does Pro include Fable 5.1?

    No. Pro can call it with usage credits. Included Fable lives on Max and premium seats only, and only up to half the weekly limit.

    Is Fable 5.1 2.5× Opus 5.5 (and 2× legacy Opus 5)?

    Against current Opus 5.5 ($4/$20), Fable at $10/$50 is 2.5× on list rates. Against legacy Opus 5 ($5/$25) it is still 2×. Opus 5 Fast mode lists at Fable’s standard rate. Pick Fable when the job is long-horizon and you have Max/premium inclusion or a reason to pay the cache-aware API bill.

    Does the Batch API discount apply to Fable?

    Yes. Anthropic’s Batch API takes 50% off standard rates across models, Fable included — roughly $5/$25 per million input/output tokens on Fable 5.1 for non-urgent work. Cache-read pricing discounts stack on top.

    Do cache writes cost extra on Fable 5.1?

    Yes, one line item to know: 5-minute cache writes are $12.50 per million (1.25× input), 1-hour writes are $20 (2× input). You pay the write once when the cache entry is created; every re-read after that bills at the $0.25 cache-read rate. Writes are a footnote — reads are the story.

    How does the 50% weekly pool cap work for Fable on Max?

    Max and premium Team/Enterprise seats include Fable, but only up to half of the weekly usage pool — Fable can’t consume the whole allowance. Past the cap, further Fable usage bills as usage credits from the first token. If Fable is your daily driver on a plan, watch the pool split, not just the total.