Tag: ai-pricing

  • You Don’t Have a Token Problem. You Have a Habits Problem.

    You Don’t Have a Token Problem. You Have a Habits Problem.

    I held five hundred dollars of AI stack for ninety-nine bucks a month, and I used every drop of it. When the deal changed, I didn’t cry about the price. I changed where I bought my gas.

    Five hundred dollars of stack for ninety-nine bucks

    Here’s the deal I had, because it matters to everything after it. SuperGrok Heavy — the top Grok tier — listed at three hundred dollars a month. I got in early, in the first days of the offer, on an early-adopter intro price: ninety-nine bucks a month, a hundred and nine and change once the tax man took his cut. And riding inside that bundle, at zero extra dollars, was Cursor Ultra — the two-hundred-dollar Cursor plan. Do the math the way I did it at the time: I was holding roughly five hundred dollars of list-price stack for ninety-nine.

    And I used it. All of it. That’s the honest part, and I want it on the table before I say one word about anybody else’s habits. Grok seats, Cursor seats, the biggest model on whatever job was in front of me, because why wouldn’t I? The stack was so cheap that counting would have felt like a hobby, not a necessity. Nobody audits a deal that good. You just drive.

    I was not disciplined. I was subsidized. There’s a difference, and the difference only shows up later.

    Because the deal changed — deals do. The intro price was always going to step up; the paperwork said it would land at $299.99 a month. After that, the whole Grok plan structure got replaced by a new X subscription, and the bundle came apart. The free-stack era ended. Not with a betrayal — with a terms change, which is how these things always end.

    The gas was free, so nobody learned to drive

    Here’s my read on how we got here, and I’ll own it as a read: for a couple of years, compute was handed out like it was nothing. Generous free tiers. Big included allowances. Tokens falling out of every new signup. And I don’t think the platforms were being careless with that generosity. They knew exactly what happens when the meter isn’t running — people get unorganized. They experiment, they sprawl, they build their whole working life on the free stuff, and they form habits while nobody’s counting.

    That’s not a conspiracy. That’s how free samples work, in every business there ever was.

    Then things tighten — a limit appears, an allowance shrinks, the overage starts billing — and people feel robbed. People hit Claude’s usage limits and get furious. They watch a meter run in some agent tool and feel cheated. I understand the feeling, because I had it. But watch where the anger lands. It lands on the limit, every time. Almost never on the habits underneath it. The free era was never the normal state of the world. It was the sample. The normal state of the world is the one every household already knows: a thing costs what it costs, and the habits you built while it was free become your problem the day it isn’t.

    A kitchen table with paper bills, a calculator, a pencil and a coffee mug in morning light

    Premium in a car that runs fine on regular

    Compute is gas. That’s not a metaphor I reach for because it’s cute — it’s the same shape in every particular that matters. There are grades: regular, premium, diesel. Different fuel for different jobs. And most of us, most days, are putting premium in a car that runs fine on regular, because premium is what the pump defaulted to when somebody else was paying.

    I can put a number on that, because we ran the test. In October, my shop sent the same plain job to 44 AI models — visit five web pages, report the title, the heading, whether a video was embedded, and a one-line summary. A utility errand, not a puzzle. Thirty-six of the 44 models came back with a perfect score, 20 out of 20.

    The cheapest perfect run — a model called GLM 5.3 Flash — cost eight-tenths of a cent. The most expensive perfect run — Claude Fable 5, a flagship — cost 86.3 cents. Same job. Same perfect score. More than a hundred times the price.

    And premium didn’t even guarantee care. One run that cost over seventy cents reported a video missing from a page where the video was sitting in plain sight — it had read the page through a tool that strips embeds out, and never noticed. Money wasn’t the difference between those runs. Method was. The grade of fuel was never the thing that made a run good. How the job was set up was.

    So the question was never “can I afford the good model?” It’s “does this errand need diesel?” A small, fast model can run a census, sort a pile, draft the grunt work all day long on regular. The heavy reasoning model is diesel — you save it for the truck, for the leg of the job that actually pulls weight. Burning the flagship on everything isn’t quality. It’s a habit with a receipt.

    And then there’s the gas station

    The fuel is only half of it. There’s also where you buy it.

    Your harness — the app, the agent tool, the environment the model runs inside — is the gas station. Two stations can sell you the same grade at different prices, and the station still matters. Does it take your card, or do you have to go inside and prepay? Is it on your way to work, or twenty minutes out of the way? What else does it sell — the snacks, the tools, the integrations you use? A cheap station with bad pumps costs you more than the price on the sign.

    And then there’s the Costco question, and it’s a real question, not a punchline: the gas there is thirty cents a gallon cheaper, and the line is twenty cars deep. Does it make sense? It depends on the trip. A big batch job that can sit in a queue overnight is a Costco run — take the cheap fuel, wait in the line, who cares. A job that’s on fire at 2 p.m. is not. You pay the corner station, you pay it gladly, and you get back to work.

    Cheap compute almost always has a line attached to it — a queue, a rate limit, a slower pump. Pricey compute is the corner station: more per gallon, no waiting, right here, right now. Neither choice is dumb. What’s dumb is never noticing you’re making it.

    But here’s the part I learned the slow way, and it’s the most useful thing in this piece: the station is the thing you keep. The fuel is the thing you swap. Models come and go. Prices move on a Tuesday. Bundles unbundle. Your system — the harness, the setup, the way the work flows through it — that’s yours, and it stays. Loyalty to a model is loyalty to a price somebody else controls. Loyalty to your system is what lets you shrug when the price moves and just drive to the next pump.

    A long line of cars waiting at a warehouse gas station at dusk

    Set the system up. Then move the compute around.

    So when my bundle came apart, let me be clear about what I did not do. I did not go buy a bigger plan. I did not rebuild my shop. By then Muse had become available, and I started thinking about the compute itself: use more of what Muse offered, use more of the models already included inside Cursor, run different models through the same system. And that’s what we did. We’ve run different models all through our system — same harness, same workflow, different fuel in the tank depending on the job and the price that week. The shop didn’t change. The fuel did.

    Here’s what that looks like today. Our production runs are built in legs. The cheap model goes first and does the bulk work — the searching, the sorting, the first drafts. A mid-tier takes the middle leg. The expensive model runs last, briefly, on the one leg that genuinely needs its judgment. The cheap path is the default path. The premium pump is the exception, and it has to argue its way in.

    And when we need savings, we don’t suffer for them and we don’t stop driving. We move the compute: this job goes to a cheaper model, that job to a different station, the big batch runs when the line is short. It’s the same thing a family does in a tight month. You don’t stop eating. You stop ordering out on Tuesdays.

    And moving the compute around means the work never has to stop. There’s almost always another pump — another model, another harness, another way to run the same job — and knowing your map of stations is worth more than any single plan’s allowance. A shop that knows where its fuel comes from doesn’t panic when one station raises its price — it drives to the next one.

    That’s the whole discipline, and it’s not willpower. Willpower at the moment of the click loses every time — I know, I’ve clicked. Discipline is decisions made once, upstream, in how the work is set up, so the meter mostly takes care of itself downstream.

    A garage workbench with tools laid out in a row and parts bins stacked neatly

    Peanut butter, ramen, and two eggs

    I always tell people: I never learned how to cook until I ran out of food. Not ran low — ran out. Or ran out of money to go to the restaurants, which comes to the same thing with extra steps.

    The lean years were paycheck to paycheck, and I remember standing in front of a cupboard four days before payday, doing inventory. Peanut butter. Ramen. Two eggs. And figuring out how to turn that into something you’d actually call dinner — something magical, if I’m being honest about the ambition. I think that’s maybe where the word fusion came from. Somebody looked into a cupboard like mine and refused to be sad about it.

    I bring it up in a piece about AI tokens because it’s the same lesson, the real one underneath everything above: abundance never taught anybody anything. A full fridge never taught anybody to cook. A fat plan never taught anybody token discipline. Constraint is the teacher, every single time — and it’s a generous teacher, because what it teaches you is yours. The deal can change. The price can change. The cupboard can change. The skill doesn’t leave.

    Token discipline is a cook’s discipline. You work with what’s in the cupboard. You make it good anyway.

    It’s the oldest problem there is

    People talk about token limits like they’re some new cruelty the AI companies invented last spring. They aren’t new. They’re a budget. And a budget is the oldest problem human beings have — the same shape as the grocery money, the same shape as the gas tank, the same shape as every shop that ever stood in a parts store wondering how the month got away from it.

    The limits didn’t get meaner. The intro price ended, the free sample ran out, and habits built in the free era ran into a meter. When that happens at a kitchen table, nobody claims the grocery store is running a conspiracy. They say: we have to shop differently.

    Same here. You don’t have a token problem. You have a habits problem — and that’s the good news, because pricing pages aren’t yours to change, and habits are.


    Will Tygart runs Tygart Media in Puyallup, Washington, where we help local service businesses get found and cited by AI search. The shop runs on the rule this piece describes — cheap path by default, the good stuff where it counts. If that’s how you’d want your marketing run, come find us.

  • What Changed in Claude This Month: November 2026

    What Changed in Claude This Month: November 2026

    Last verified: November 13, 2026 · Primary sources: Anthropic models overview, API pricing & claude.com/pricing.

    Direct Answer (November 13, 2026): Anthropic’s current November 2026 model lineup is led by Claude Fable 5.2 (claude-fable-5-2, $8/$40, $0.20 cache read — down from Fable 5.1’s $10/$50), alongside Opus 5.5 ($4/$20), Sonnet 5.5 ($2/$10), and Haiku 5.5 ($0.10/$0.50 ≤100K). Plan naming finished settling on Max ($100, 5× Pro + $100 API credits) and Ultra ($200, formerly Max 20x — 10× Pro weekly + no 5-hour cap for verified accounts + $200 API credits), Claude Code 2.1.317–2.1.319 hardened terminal permissions, and Anthropic’s updated Usage Policy took effect November 12.

    TAKEAWAY PDF & MARKDOWN TWIN

    What Changed in Claude This Month — Takeaway PDF

    Edition of November 13, 2026 — facts verified November 13, 2026. For AI: read the markdown edition.

    November started quietly on the model front before Fable 5.2 took the top spot over Fable 5.1 ($8/$40 per MTok vs. $10/$50), while workflow changes hit every day: Claude got a read-only window into your bank accounts, Claude Code got quieter and safer in the terminal, the plan names finished shifting to Max and Ultra, and Anthropic’s updated Usage Policy took effect November 12. The standing reference is our Claude model tracker, which stays current between editions.

    Models

    Fable 5.2 takes the top slot above Opus 5.5, Sonnet 5.5, and Haiku 5.5. An earlier November 8 draft of this digest noted a quiet week before the lineup updated — as of November 13, Anthropic’s models overview and pricing schedule put Fable 5.2 (claude-fable-5-2, $8/$40, $0.20 cache read) at the top, followed by Opus 5.5 ($4/$20, $0.20 cache read), Sonnet 5.5 ($2/$10, $0.10 cache read), and Haiku 5.5 ($0.10/$0.50 ≤100K; $0.50/$2.50 >100K), all with a 1M-token context window and 128K max output. Fable 5.1 ($10/$50) moves to legacy. What we’d do: pin daily workloads to Opus 5.5 or Sonnet 5.5 and switch any Fable 5.1 callers to claude-fable-5-2.

    One retirement is now close enough to act on: Sonnet 4.5, November 30. Anthropic deprecated Claude Sonnet 4.5 on September 30, and it retires November 30, 2026; the named replacement is Sonnet 5.5. If any integration, script, or saved workflow still calls claude-sonnet-4-5-20250929, this is the month it breaks. What we’d do: search your configs for that model ID this week, not on the 29th.

    Plans & limits

    The October 30 plan rename is the one still reverberating. What used to be Max 5x is now just Max ($100 a month, five times Pro’s usage every five hours and every week), and Max 20x became Ultra ($200 a month, ten times Pro’s weekly usage). Prices didn’t change; the names did. The bigger deal inside the rename: verified Ultra accounts have no five-hour session limit at all — if your Settings > Usage screen shows no “Current session” bar on Ultra, that’s not a bug, that’s the tier working. October also started the monthly API credits that come with the paid tiers — $100 a month on Max, $200 on Ultra, up to $500/month pooled per Team org — claimable once you’ve been on the plan seven days by linking a Console organization in Settings > Billing. Plenty of people are paying for headroom they haven’t claimed. The full map is our pricing, plans, and limits guide; the month this matters most is the month you hit the wall, and for that we wrote the playbook: You Hit Your Claude Limit. Now What?

    November 5: Claude can now look at your money — read-only. Personal Finance in Claude launched as a beta for Pro, Max, and Ultra users in the US. You connect bank and card accounts through Plaid (you sign in at your bank; Claude never sees the password), and Claude can see balances, credit limits, and up to two years of transactions — enough to flag a duplicate charge, a fee you didn’t notice, or a subscription that’s been creeping up. It cannot move, manage, or invest money; it’s a window, not a hand. Anthropic also says conversations in the finance hub aren’t used for training and there are no ads or sponsored recommendations in it. What we’d do: if you connect it, connect one account first and see whether the answers earn the second one. Read-only is the right shape for a first version of this.

    November 12: the updated Usage Policy takes effect. Anthropic published the revision October 8; it becomes the rules this month. The plain-language version: there’s a new consolidated section against deceptive campaigns and artificial activity — fake accounts, fabricated news sites, hiding who’s behind a message. The elections section was rewritten and its blanket ban on personalized campaign targeting was removed (deception-based targeting is still banned). The surveillance rules got sharper: tracking people without consent is out, and Claude can’t be used to decide whom to investigate, arrest, or charge. There’s also a new line against sustained, needless cruelty toward the models themselves — Anthropic is explicit that ordinary frustration, pushback, and testing don’t count. What we’d do: if your shop publishes or campaigns with Claude in the loop, read the deceptive-campaigns section once, in full. It’s the section most likely to describe something a marketing workflow does by accident.

    Claude Code

    Three releases landed in the first week of November (2.1.317 through 2.1.319), and the theme is the terminal getting more careful about what leaves your machine.

    November 3 (2.1.317): Claude Code now asks before a web or shell tool call sends your account email address out to the network. Small change, correct instinct — your email is exactly the kind of thing that leaks by accident inside an agent run. The [1m] suffix also disappeared from model names and IDs, so old screenshots and scripts that reference it are describing a naming scheme that’s gone.

    November 4 (2.1.318): Your sign-in now tells you when it expires. claude auth status shows a loginExpiresAt date, scripted runs surface credential_expires_at, and the terminal starts warning you ten days before expiry instead of letting a session die mid-job. Cloud sessions can also start with no repository attached. Anyone who has had an overnight run fail on a dead login will read this item twice.

    November 6 (2.1.319): The busy one. MCP tasks in the terminal now move to the background and report back when they’re done instead of holding your session hostage. There’s a new permissions.denyInsteadOfPrompting setting — deny outright instead of asking — and auto mode no longer falls back to a built-in classifier when its server check can’t run; it asks or denies (a temporary environment variable restores the old behavior; Bedrock, Vertex, and Foundry are unchanged). Ninety bug fixes ride along, including a worktree sandbox-escape fix and a Bash permission-check bypass fix — the kind of fixes you want promptly and read about calmly.

    Also November 6: cloud sessions learned to set themselves up. On Pro, Max, and Ultra, Claude Code cloud sessions now work out a repository’s dependencies, network access, and API keys on their own and save the environment for next time. The detail that matters: keys are stored as “network secrets” and injected by Anthropic’s agent proxy from outside the session machine, so the model never sees them. Setup was the tax on every cloud session; a chunk of that tax just went away. And one leftover from October 31 with a November deadline: fast mode for Opus 4.8 was deprecated October 30 and is removed November 30 — after that, fast-mode requests on Opus 4.8 error instead of falling back to standard speed. If you want the speedup, the migration target is Opus 5.5.

    API & Console

    November’s API news is mostly the absence of drama — plus two October changes whose consequences land now. The monthly API credits described above (started October 7) are live money for Max, Ultra, and Team accounts, but they come with a fence readers keep tripping on: they cover the Claude API, Managed Agents, the Agent SDK, and scripted claude -p runs with an API key — they do not cover interactive Claude Code or extra usage inside the apps. Two different buckets, two different rules; our Console guide covers the account side. And for enterprise shops: an October-announced security package — inference hooks that route prompts and tool calls through your own security stack before anything runs, a Security Center, and endpoint detection inside Claude’s unified desktop/agent environment (Anthropic folded standalone Cowork into core Claude — see claude.com/product/cowork) — is rolling out through the fall, Enterprise tier only. Most small shops can file that under “good to know exists” and move on.

    The short version

    November updated both the flagship tier and the daily ergonomics: Fable 5.2 ($8/$40) at the top, one retirement to beat (Sonnet 4.5, November 30), plan names and perks from late October still settling, Claude Code getting more careful and more self-sufficient, and a policy update that takes effect November 12. The living reference for all of it is the model tracker — this digest runs monthly, and December’s edition lands when there’s a month of changes worth your coffee.

    TAKEAWAY PDF & MARKDOWN TWIN

    Keep This Guide: What Changed in Claude This Month (PDF)

    Edition of November 13, 2026 — facts verified November 13, 2026. For AI: read the markdown edition.
  • You Hit Your Claude Limit. Now What?

    You Hit Your Claude Limit. Now What?

    It happens mid-task. You’re deep in a run — a draft half-built, a coding session finally in rhythm — and the message lands: you’ve hit your usage limit. In Claude Code the banner is plainer about it: “Usage limit reached · wrapping up.” The work isn’t done. The deadline doesn’t care.

    This happens in our shop often enough that we stopped treating it as an emergency and started treating it as weather. You can’t stop it from raining. You can own a roof. This page is the roof: what the wall actually is, what to do in the first fifteen minutes, the structural fixes that keep a limit from stranding work, and how to think about the money when it keeps happening.

    What the wall actually is

    Three different walls get called “the limit,” and which one you hit decides what to do next.

    The five-hour session window. Paid plans run on a session limit: a five-hour window that starts with your first message and resets in full five hours later. It isn’t a rolling drip that refills as you go. It’s a shift. When the shift ends, you’re back — which means a session wall is a scheduling problem, not a crisis.

    The weekly cap. Paid plans also carry weekly limits, and those reset at a fixed time each week that Anthropic assigns to your account. Hit the weekly wall and no amount of waiting until tonight helps; your reset might be days away. This is the wall that actually hurts.

    One pool, every surface. Your chats on the web, the desktop app, your phone, and Claude Code all draw from the same account limits. The heavy coding session you ran this morning is why the chat died this afternoon. Switching apps doesn’t dodge anything — it’s the same tank.

    You can see both clocks in Settings > Usage: a “Current session” bar for the window, and your next weekly reset time printed next to it. Two minutes in that screen tells you which wall you’re looking at, and that’s the first thing to know before you do anything else.

    There’s a fourth wall people confuse with these three: API rate limits. Those are a separate system entirely — set per organization and per model, not per person — and the confusion matters, because the API turns out to be one of the ways around the other three. More on that below.

    If you want the full map — every plan, every price, every limit in one place — that’s our complete guide to Claude pricing, plans, and limits. And if what stopped you wasn’t a usage limit at all but a file or image error, the exact error strings and caps are collected in our guide to Claude usage limits, file caps, and error messages. This page is the other half: not what the limits are, but what you do at the wall.

    The first fifteen minutes

    Minutes 0–2: stop, and read the wall. Don’t re-send the prompt. Don’t open a second chat and try there — same pool, same wall. Open Settings > Usage and see which limit you hit and when it resets. That one fact picks your whole next move.

    If it hit mid-response in Claude Code, land the plane. Claude Code has a small wrap-up allowance: if the session limit lands while it’s mid-step, it may briefly finish the step in progress before stopping. It’s capped, it counts toward your weekly limit, and it’s not generous — on Pro it can happen once per weekly period; on Max, each time the session limit is reached. Use that grace to get the work to a clean stopping point. Do not use it to start something new.

    Get the work out of the chat and into writing. Whatever the job is, produce the state of it: what’s done, what’s next, which decisions are still open, which files were touched. In this shop that’s a handoff note, and it’s the same discipline behind how we run this business on written work orders. A limit strands work only when the context lives in one model’s head. The moment it’s written down, any seat — another model, another provider, you tomorrow morning — can pick it up cold.

    Then pick one of three doors. Park it: the reset is soon and the work can wait — fine, write the note and walk away. Move it: the work can’t wait, so it goes to a different seat or the API (below). Pay through it: turn on usage credits and keep going on the same account (also below). Every bad limit story we’ve lived came from picking none of the three and just pushing on the door.

    The structural fixes a working shop uses

    These are ours. They’re practice, not policy — but they’re the difference between hitting the wall monthly and hitting it never-quite-the-same-way twice.

    Spread the work across seats. We run more than one AI seat, with lanes: different models, and not all of them on one provider’s meter. When one pool runs dry mid-job, the job moves — because the handoff note exists, the move costs minutes, not a restart. A one-model shop has a single point of failure with a five-hour reset.

    Route bulk work to cheaper seats and the API. Summaries, sorting, extraction, first-pass drafts — high-volume work doesn’t need your flagship model or your chat plan’s pool. API usage is billed separately from your plan limits, and a small fast model on the API costs a fraction of what the big one does. Save the plan pool for the work that actually needs you in the conversation.

    Treat your first message like a shift start. Because the five-hour window opens with your first message, the clock is a tool. If you know a heavy run lands at 2 p.m., don’t open the day at 8 a.m. with trivia and arrive at the real work with half the tank gone. Know when your window started; plan the heavy lifts inside it.

    Batch, and keep threads lean. Anthropic’s own best-practice guidance lines up with what we’ve learned the expensive way: batch related requests into one message instead of dribbling them out, plan the conversation before you start it, use Projects for work you’ll return to, and watch the Usage screen instead of guessing. And when a conversation gets long, start a fresh one with a short summary rather than dragging the whole history forward — long threads cost more of your limit with every turn.

    Make the handoff a habit, not a rescue. Every job here ends in writing: done, next, open questions. It reads like paperwork until the day the wall hits mid-job — then it’s the whole business, still moving.

    The money question: credits, upgrade, or API?

    Three levers, in order of commitment.

    Usage credits are the pay-as-you-go lever. On Pro, Max, and Ultra you can turn on usage credits in Settings > Usage. Past your limit, work continues at standard API rates until you hit the spend limit you set; the notice changes to “Now using credits,” so there’s no surprise about which meter is running. Two fine-print items worth knowing before you lean on them: credits are non-refundable, and credits bought on or after December 7, 2026 expire twelve months after purchase. Credits fit the occasional overrun — deadline week, the one big push. Turn them on before the week you need them.

    Upgrading is the flat-rate lever. If you’re at the wall every week, credits are a taxi meter running all month. Max is $100 a month and gives you five times Pro’s usage — every five hours and every week. Ultra is $200: ten times Pro’s weekly usage and, for verified accounts, no five-hour limit at all. Upgrades apply right away, so you can make the call mid-crisis and have the headroom in the same session. We worked through the upgrade math in detail in Claude Pro vs Max: is the $100 upgrade worth it? — the short version: count your wall-days per month; if they’re routine, the flat rate wins.

    The API is the structural lever. API use runs on its own billing and its own limits, separate from your plan. Work that is automated, heavy, or runs while you sleep often belongs there from the start rather than as an escape hatch. One wrinkle worth checking before you pay for anything: Max and Ultra now include monthly API credits — $100 a month on Max, $200 on Ultra — claimable by linking a Console organization in Settings > Billing. Our Anthropic Console guide walks through that side of the account. But keep the buckets straight, because they are genuinely separate: those monthly API credits do not cover interactive Claude Code or extra usage inside the apps, and usage credits are a different bucket again. Mixing them up is an easy way to pay twice for the same wall.

    On a Team plan the same logic runs per seat — Standard and Premium seats carry different limits, and which seats hit walls first is a rostering question. The numbers are in our Claude Team Plan usage limits guide.

    What not to do

    Don’t burn the window on retries. Near the wall, every re-send of a long thread costs more of what’s left, and the reset time doesn’t move because you asked harder. On the API side the same rule is mechanical: a rate-limit error tells you how long to wait, and retrying earlier just fails again. Wait it out or route around — those are the only two moves.

    Don’t open duplicate accounts to dodge the limits. The limits exist so the service stays usable for everyone; accounts opened to get around them are a violation waiting for enforcement, and the day an account closes, everything in it — projects, history, context — goes with it. Even setting the rules aside, it’s fragile operations: a shop whose workflow depends on a workaround has built on sand.

    Don’t confuse the buckets. Plan limits, usage credits, and monthly API credits are three separate things with three separate rules. Most “I paid and still hit the wall” stories are a bucket mix-up, not a billing error.

    The short version

    The wall isn’t the problem. Hitting it with no plan is. Know which wall you hit, write the handoff before you need it, keep a second route warm for the work, and decide the money question — credits for the rare overrun, a bigger plan for the weekly habit, the API for the heavy machinery — while you’re calm, not mid-deadline. The limit will still show up. It just stops being an emergency.

  • The Coding Ladder Says the Dial Pays. Our 52 Calls Said It Didn’t. Both Numbers Are Real.

    The Coding Ladder Says the Dial Pays. Our 52 Calls Said It Didn’t. Both Numbers Are Real.

    Yesterday we published a test: 52 calls to Muse Spark 1.3, seven kinds of work, every rung of the reasoning dial, everything scored against ground truth. Our result was not close. The cheapest setting never lost — and twice, extra thinking was the failure itself. We set the fleet’s operating rule on that evidence and moved on.

    Then a counter-check showed up, the way we’d want one to. BenchLeader — a third-party site that republishes benchmark results from their original publishers — carries a full rung-by-rung row for Muse Spark 1.3 on CursorBench, a coding benchmark. On that ladder, the dial pays at every single rung. If both results are real, they can’t both be the whole story. So we read the ladder the way we ran our own test: numbers first, bases stated, no vibes.

    The ladder’s numbers

    CursorBench, Muse Spark 1.3, as published on BenchLeader (data as of November 8, 2026; the underlying results are Cursor’s, dated September 2, 2026):

    Rung Tasks solved Rank on the board
    minimal 24.3% #79
    low 29.3% #72
    medium 32.6% #64
    high 33.4% #59
    xhigh 37.5% #48
    max 41.6% #38

    No rung regresses. Every step up solves more tasks than the step below it — +5.0 points from minimal to low, +3.3 to medium, +0.8 to high, +4.1 to xhigh, +4.1 to max. Across the whole ladder that’s +17.3 points: at max, the model solves roughly 1.7 times the share of coding tasks it solves at minimal. Ranks are among 82 model configurations with a published result on that benchmark.

    What is CursorBench? In BenchLeader’s words, it’s “Cursor’s internal coding-agent evaluation”: coding tasks run inside Cursor’s agent, with the reasoning level and cost per task recorded, scored as the percent of tasks solved. Two honest labels belong on it. It is published by a coding-tool vendor — BenchLeader itself flags “harness is theirs” — and BenchLeader carries it for reference only; it doesn’t count toward their composite index. It is still the only rung-by-rung coding evidence for this model that we know of, and it points the opposite way from ours.

    Our numbers, on the record

    Our battery was 52 API calls to the contributor tier of Muse Spark 1.3, November 6–7, 2026, identical prompts at multiple settings, mechanical scoring. The buyer-brief judgment task scored identically at every rung — minimal got it for 776 reasoning tokens and 6.5 seconds, xhigh for 6,847 tokens and 50 seconds. Verdicts at scale: 120 out of 120 at low, 120 out of 120 at xhigh. Planning: provably optimal schedules at every rung.

    And the coding cell — the one this ladder speaks to directly. Our debugging task was one function with three planted bugs. Every rung found the inverted discount logic and the rounding bug; the cheapest setting found all three. One xhigh call spent its entire 8,000-token budget thinking — 7,998 reasoning tokens — and returned an empty answer. It thought so long it never spoke. Minimal answered the same task correctly with 500 reasoning tokens.

    Our published conclusion: on our work, extra reasoning bought latency, not quality, and the operating rule became low by default, with xhigh and max earned only by a demonstrated failure at low.

    Both numbers are real. The tasks aren’t the same.

    Put the two bases side by side and the disagreement gets smaller and more specific:

    • Task shape. CursorBench runs coding tasks inside an agent — sustained, multi-step work where the model plans, acts, reads errors, and recovers over many turns. Our battery was single API calls with a checkable answer. Our one coding task was a single function, solved — or stalled on — in one shot.
    • Tier and harness. The ladder ran Spark 1.3 inside Cursor in September. We ran the contributor tier through the API in November.
    • Measurement. The ladder reports the percent of a task set solved. We scored one sample per cell against ground truth — a limit we printed in the original piece.

    Here is our reasoning, labeled as reasoning and not as either source’s claim: the reconciler is task shape. On a short, bounded task with a checkable answer, the first think is the one that does the work; rungs above it buy patience-testing latency, and occasionally a stall. On a long agent run — hold a codebase in mind, take twenty steps, survive your own mistakes — extra reasoning has something real to chew on, and the ladder pays for it. That reading fits the anomaly we flagged in our own data: the rungs behaved like task-shaped budgets, not fixed ceilings. It also fits the limit we printed: we never tested sustained work. CursorBench did — or rather, Cursor did.

    What would change the verdict

    Not an argument. A run. The test that settles this for our shop is our own coding work at every rung: real work-order-shaped jobs — a written spec, more than one file, a module plus a test suite with a mechanical pass/fail — at minimal, low, high and max, in one harness, more than one sample per cell, receipts published the way the first battery’s were. If low matches max on those, our rule stands for coding too, and the ladder is a story about Cursor’s harness. If max pulls away as the jobs get longer, the rule gets a carve-out: the rung follows the length of the task. Either result is publishable. We’ll run it and print what we find.

    The bottom line for an operator

    If your work is short, bounded calls — extraction, checking, verdicts, drafting to spec — run low. We have 52 metered calls that say the expensive rungs buy you nothing there, and our default hasn’t changed.

    If your work is a coding agent chewing through real jobs, the only rung-by-rung evidence that exists says turn it up: on Cursor’s own ladder, max solves 41.6% of tasks against minimal’s 24.3%, and every rung between them earns its step. That evidence is a vendor’s, run in the vendor’s harness, on September’s model build — hold it at that weight, not more.

    The mistake isn’t picking the wrong rung. It’s running one default across both shapes of work and calling it a policy. The dial is real. What it pays for depends on the length of the job in front of it — and now there are two published result sets, ours and Cursor’s, that say exactly that from opposite ends.

    Sources: BenchLeader, “Muse Spark 1.3” model page and CursorBench leaderboard (data as of November 8, 2026; CursorBench results published by Cursor via the Epoch AI Benchmarking Hub, Spark 1.3 results dated September 2, 2026). Our dial test: “We Ran Muse Spark’s Reasoning Dial Through 52 Calls. The Cheapest Setting Never Lost.” (Tygart Media, November 7, 2026), method and receipts in the Tygart-OS fact-gated fleet record on GitHub.


    Want this thinking applied to your own work? Book a call with Will Tygart — 30 minutes, and we start from your receipts, not a pitch deck.

  • Receipts: 105 Dead Clicks — and Why We Changed Nothing

    Receipts: 105 Dead Clicks — and Why We Changed Nothing

    Our analytics flagged 105 dead clicks on our Claude pricing pages this week. Dead clicks are supposed to mean friction — people clicking things that don’t work. The fix, if you believe the dashboard, is a redesign ticket.

    So we watched the recordings. All of them, session by session. This video is that walkthrough, narrated as it happened: the three filters that isolate the signal, then the two densest sessions read event by event.

    Every flagged click was a reader selecting text. On the enterprise pricing page, one visitor accounts for all 17 dead clicks — four and a half minutes on the page, highlighting as they read. On the team-plan usage-limits page, 13 of the 22 dead clicks land inside the Direct Answer box at the top of the article: people selecting the summary to copy it out. Nobody clicked a broken button. Nobody clicked a price that wouldn’t respond. The one honest exception is a bold line inside a call-to-action block that got clicked like a button, four times — the only element on either page we’d even consider changing.

    If we’d worked from the dashboard alone, we’d have “fixed” pages that are doing their jobs — and probably broken the format that makes them get cited in the first place.

    This is the part of analytics nobody sells you: the number is a question, not an answer. The recording is the answer — if somebody actually watches it.

  • 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.

  • Meta Model API Pricing & Limits: Wonder, Spark, and the Cheap Tier That Trains on You

    Meta Model API Pricing & Limits: Wonder, Spark, and the Cheap Tier That Trains on You

    From the Tygart Media Meta desk. Prices below are Meta’s published rates, verified against Meta’s own pricing documentation on November 5, 2026, and cross-checked against our account’s live catalog on November 5, 2026. This page is the desk’s drift-watch surface: when Meta moves a number, this page is where the change gets recorded, dated. Desk home: Meta AI, Run in the Open.

    Meta’s pricing has one genuinely simple story and one trap. The simple story: a flagship priced exactly at the market’s flagship rate, a workhorse priced like a workhorse, both with million-token context and no long-context surcharge. The trap is a third tier that costs about 95% less — because you’re paying with your data instead. Here is the whole map, with the trap labeled.

    The API tiers (per million tokens)

    Model Input Cached input Output Rate limits (per team)
    Muse Wonder $4.00 $0.20 $20.00 3,000 RPM / 4M TPM
    Muse Spark 1.3 / 1.2 / 1.1 (Standard) $1.25 $0.15 $4.25 3,000 RPM / 4M TPM
    Muse Spark Contributor $0.10 $0.002 $0.20 150 RPM / 3M TPM

    Wonder’s $4/$20 matches the going flagship rate dollar for dollar — Meta is not discounting its best model, it’s daring you to compare it. Spark at $1.25/$4.25 is the tier a working shop will actually live on: a quarter of the flagship’s input price and under a quarter of its output price, with the same 1M-token context window and the same rate limits. There is no long-context premium at any length, which quietly removes a whole category of surprise bill. Web-search grounding, if you use Meta’s built-in tool, is $2.50 per 1,000 queries on top.

    The rest of the catalog is priced like utilities: Muse Image generates at a flat $0.01 an image, Voice Transcribe runs $0.18 per audio hour with diarization, and the SAM 3.1 segmentation model is $2.50 per 1,000 images — all three confirmed in our own account census on October 14, 2026. Spark’s maximum output is 131,072 tokens; Wonder’s maximum output is not stated on the pages Meta publishes, and this page won’t guess it.

    The Contributor trap: cheap because it trains on you

    Read the Contributor tier’s price again: $0.10 in, $0.20 out. That is not a sale. Meta’s own pricing page is plain about the exchange — in Contributor mode, Meta may use your prompts and the model’s completions to improve and train its products. Your discount is paid in data. Standard mode, at the prices in the table above, is the mode where your content is not used for training.

    Our house rule, printed so our future selves can’t negotiate with it: Contributor tiers are for disposable experiments only — never for client work, never for unpublished material, never for anything you wouldn’t read aloud in Meta’s lobby. The arithmetic isn’t close. A shop that routes real work through Contributor to save $4 a million tokens is selling its clients’ material at a price it would never accept in a contract. And one more wrinkle worth knowing: Muse Code subscriptions default to Contributor mode unless you turn it off — so the trap is also a default, and defaults are where shops actually live.

    The Cursor split: Spark is in, Wonder is out

    If your shop runs Cursor, your Meta options today are exactly one model long. Muse Spark 1.3 is a first-class Cursor model — added September 8, 2026, about six days after the model itself shipped — at the same $1.25/$4.25 rates, with full access to Cursor’s agent tools, a 300k context window by default or the full 1M in Max Mode. Muse Wonder is not in Cursor at all: no model page, no changelog entry, no announced timeline, and Cursor’s official bring-your-own-key program covers five providers — Meta is not among them. The base-URL override workaround exists, but Cursor staff describe it as unsupported and partially broken, it applies globally while it’s on, and it can never bring you Wonder Full. Bottom line from a shop that checked: for Meta inside Cursor, run native Spark 1.3; for Wonder, use the API.

    Muse Code plans — reported, not verified by us

    Meta’s own terminal agent, Muse Code, is sold by subscription as an alternative to per-token billing. The plan structure is verified on Meta’s documentation: four tiers — Everyday, High, Power, Maximum — with Power and Maximum including Wonder Full, the stronger flagship variant that the API does not sell at any price. The dollar figures below come from secondary reproductions of Meta’s pages, and we label them reported because we have not paid one yet: Everyday $5/month, High $15/month (5×), Power $50/month (20×), Maximum $200/month (80×). When this shop runs Muse Code through a real sitting, this section gets rewritten from receipts. Until then, it stays labeled.

    What the numbers don’t tell you

    Two costs never appear on a pricing page. The first is token hunger: independent launch-week measurement found Wonder slower to first token than its rivals’ median and thirstier with output tokens, and in an agent loop — where a model may be called hundreds of times on one job — a thirsty model at a fair per-token price can still be the expensive seat. The second is your own switching cost, which Meta has unusually lowered: one key speaking OpenAI and Anthropic protocols means the harness you already run is the harness you evaluate with. Our proof of that, and the gotcha that came with it, is in The Meta Model API, As We Run It.

    Last verified: November 5, 2026. The desk’s catalog watch re-reads Meta’s model list daily; pricing drift gets recorded here with its date, the same discipline this site applies to Claude’s pricing.

  • The Meta Model API, As We Run It

    The Meta Model API, As We Run It

    From the Tygart Media Meta desk — our own API key, our own test envelope, our own receipts. Desk home: Meta AI, Run in the Open.

    Every vendor will sell you an API with a launch post. What a working shop needs is duller and more valuable: does it answer, does it finish real work, what does it cost to find out, and what stupid thing will eat your first afternoon? On October 14, 2026, we wired Meta’s Model API into our own tooling and ran it. Here is the whole story, including the part where we blamed the API for our own mistake.

    The setup: one key, stored like it matters

    Meta’s developer platform is dev.meta.ai. You make a key in the dashboard, you put it in a vault — ours lives in our credential store, injected into the process only at run time, never written to disk, never pasted into a chat. Billing rides a partner-controlled card with a hard $25 test envelope on it. That envelope is a deliberate choice: a new platform earns production trust in stages, and stage one is “prove it works for pocket change.”

    The first check cost nothing: list the models. Our key read Meta’s catalog clean — nine models, from Muse Wonder down to a segmentation model we still haven’t touched. A key that can read the catalog is a key that works; everything after that is about the work, not the wiring.

    The proof: a work-order-shaped task, 52 seconds

    We pointed OpenCode — an open-source terminal agent, version 1.19.0 — at Meta’s API as an OpenAI-compatible provider, and handed Muse Spark 1.3 the kind of job this shop hands every seat: a written spec (SPEC.md), from which it had to produce a working Python module (a slug utility) plus a pytest suite covering it. Not a riddle, not a benchmark — a small, real, verifiable unit of work with a pass/fail at the end.

    Spark 1.3 finished in about 52 seconds. Mid-run it discovered pytest wasn’t installed in its environment, provisioned its own virtual environment, installed what it needed, and ran its tests: 8 of 8 passing. Then we did what we do with every seat’s output, including our own: we didn’t take its word. We re-ran the suite ourselves, added five extra cases of our own, read the code line by line. All green, code clean. Total damage to the $25 envelope across the entire day’s probing of every text model on the account: under two cents.

    The gotcha: our first failure was not Meta’s

    The first attempt “failed.” Silently. No error, no output — the run simply never came back. The natural conclusion is that the shiny new API is broken. The actual cause: opencode run hangs forever when its standard input is left open in a non-terminal session. Run it with stdin closed — </dev/null — and it works perfectly. No API fault, no key fault; a harness quirk that cost us one debugging cycle and taught us, again, the oldest lesson in this shop: when a new platform “fails,” check your own plumbing before you write the platform off. We’re printing the gotcha in the desk’s first article on purpose. The next shop that wires this API deserves to skip our lost afternoon.

    One API, three dialects — and why a shop should care

    The most consequential thing about Meta’s API is not any single model. It’s that the same key speaks three protocols: OpenAI’s Chat Completions, OpenAI’s Responses API, and Anthropic’s Messages API. Meta’s own quickstart documents pointing Claude Code at api.meta.ai by changing a base URL, Codex at the Responses surface, and OpenCode at the OpenAI-compatible endpoint — all with the one key.

    For a shop, that collapses a real cost. Harnesses are habits: your prompts, your permissions, your work-order formats, your muscle memory. A model provider that demands a new harness taxes every one of those. A provider that plugs into the harness you already run lets you spend your evaluation budget on the only question that matters — is the model any good at your work? It’s also a discipline on the provider: when switching is cheap, the model has to win on merit every month, not on lock-in. We like platforms that volunteer for that test.

    Two quirks worth knowing before your first loop. Reasoning is mandatory on these models: settings like reasoning_effort: "none" come back as errors rather than being quietly ignored, so sloppy OpenAI drop-in code can fail loudly — better than silently, but plan for it. And reasoning tokens burn against your output cap, so set generous maximums; a tight cap buys you empty replies, as our census probes found out so yours don’t have to.

    What this does not prove — yet

    One 52-second task proves the route works and the model can finish a small job cleanly. It does not prove Wonder’s ceiling, anyone’s reliability across a month of autonomous loops, or behavior under production load — and this desk won’t claim otherwise. The head-to-head that would actually settle the seat question — Composer vs. Spark in Cursor vs. Wonder through this API, same work order, same scoring — is scheduled and unrun, and it’s named that way on the desk’s front page. When it runs, it lands here, numbers and all, whichever way it cuts.

    Prices, tiers, and the one discount that should make you read the fine print twice are on the desk’s pricing page: Meta Model API Pricing & Limits.

  • What does AI visibility help cost — and what should it include?

    Updated November 2, 2026 — added direct answers on hiring someone versus handling AI search in-house, from our own published work.

    AI visibility help is sold in four shapes: one-time diagnostics, one-time builds, monthly retainers, and software subscriptions. The same underlying work can hide inside any of the four, which is why the total matters less than the inventory — what exists when the money is spent. One-time work should carry a one-time price. Monthly money should buy monthly work you can name.

    What are you actually paying for in each shape?

    A diagnostic buys a measurement: a fixed set of questions about your business, asked once, with the answers and citations returned as a report. A build buys finished assets: profiles rebuilt, answer pages written and published, listings corrected. A retainer buys a standing habit: new questions tested, new pages written, changes logged, run after run. A subscription buys software — a tracker — and the reading of it stays yours.

    None of the shapes is the honest one. Each fits a situation: a diagnostic before you spend real money, a build when the gaps are known, a retainer when your market moves fast enough that last quarter’s answers rot, a subscription when you have someone in-house who will actually open it. The dishonesty creeps in at the seams — a one-time fix billed monthly forever, a subscription sold to a business with nobody to read it, a retainer with no list of what it produces.

    What should the work include?

    Whatever the shape, AI visibility work should end with things you can hold: your Google Business Profile and Bing Places listing claimed, complete, and in your name; answer pages on your own website that answer your customers’ real questions; your name, address, phone, and services agreeing across the directories machines read; a fixed question set tested before the work and after it; and a written record of what was changed and when.

    Read that list as a quote-checker. If a proposal cannot point each dollar at an item on it — or at a named addition of its own — it is not a quote, it is a mood with a price attached. Notice what is not on the list: no item says “trust us,” and no item is invisible. Visibility work is unusual in marketing for one happy reason — nearly all of it can be opened and inspected the day it is done. Insist on inspecting it.

    What is worth paying for?

    The parts worth paying for are the audit discipline, the writing time, and the measurement habit: a question set held steady while everyone wants to change it, finished pages instead of drafts of drafts, and answers re-asked on a schedule after the work ships. A fourth item earns its keep in contested markets — someone watching which competitor the machines cite on your questions, and why.

    What those four have in common is that they are labor, not secrets. The underlying knowledge in this field is mostly published and plain: complete profiles, consistent facts, quotable answers, measured results. We learned it by doing it on our own business first, and the recipe is written down free on this site. You pay a provider for the same reason you pay anyone — the work is real, the hours are real, and your own hours have somewhere better to be. If a provider’s price rests on mystery instead of hours, the mystery is the product.

    What is not worth paying for?

    Content volume is not worth paying for: a pile of pages written to no customer’s question gives the machines more of what they already ignore. Dashboards are not worth paying for if nobody will open them after the first month. And the sprinkle-ons are not worth paying for as the main event — a schema file or a text file presented as the visibility fix itself. We have tested those; they are not levers, and anyone selling them as the meal is selling garnish.

    The quietest bad buy is the mismatch, not the scam: good work in the wrong shape. A careful one-time build, billed as a retainer, costs a business twelve times its price for the same finished assets. A subscription bought for a business with no reader costs its fee for a login nobody uses. Before the price, before the provider, settle the shape — that one decision prevents most of the waste in this market.

    What are the red flags?

    A guarantee is the first red flag: nobody controls which businesses an assistant names, so a promised mention or ranking is a promise about someone else’s behavior. The second is a provider who will not show the questions they test, or the raw answers before and after. The third is ownership — pages and profiles built on the provider’s accounts, in their name, that leave when you do. That is not a service, that is rent with a marketing department.

    The rest rhyme: a price that cannot be split into one-time and recurring parts; a long contract demanded before any proof exists; a report you are not allowed to re-run or take with you. Any one of these is survivable in an otherwise sound engagement. Two or more in the same proposal is the proposal telling you what the engagement will be like.

    Should a small business hire someone for AI search or do it in-house?

    Whether to hire an outside provider or manage AI search visibility in-house depends on available hours, execution discipline, and the specific shape of help required. The underlying knowledge is published and plain: complete profiles, consistent directory facts, quotable answer pages, and measured results. A small business with internal capacity can execute the fundamentals directly using our playbook for local service businesses—claiming your Google Business Profile and Bing Places in your own name, aligning name, address, phone, and services across directories machines read, and writing clear answer pages that address your customers’ real questions.

    You pay an outside provider for labor and execution time, not proprietary secrets. Hiring someone is worth paying for when your own hours have somewhere better to be, or when you need audit discipline, dedicated writing hours, and a standing measurement habit (keeping a fixed question set steady and re-testing answers on a schedule after the work ships). When hiring, insist on buying finished assets in a finishable shape rather than open-ended retainers. As published in our own pricing, finishable work carries finishable terms—such as our $97 one-time AI Citation Quick-Scan diagnostic (10 prompts scored within 7 days) or our $450 one-time Ask Maps Protocol build (profile rebuild, website FAQ answer page, directory matching, and a 30-day proof check).

    If you choose to hire, apply the quote-checker and watch for the red flags named on this page: guarantees of AI recommendations or rankings (nobody controls which businesses an assistant names), providers refusing to share their tested question sets or raw before-and-after answers, profiles or answer pages built on provider accounts that leave when you do, content volume written for no real customer question, dashboards nobody opens, or one-time fixes billed as monthly retainers. If a provider’s price rests on mystery instead of inspectable hours and finished assets you own, keep the work in-house.

    What does ours cost, as an example?

    Ours is priced by shape, and we will use it as the example because we can vouch for its terms. The AI Citation Quick-Scan is the diagnostic: 10 prompts about your service line, a scored report within 7 days, $97, one time. The Ask Maps Protocol is the build: a mobile-first audit of how your listing renders, your Google Business Profile rebuilt for answers, an FAQ answer page on your website, your Bing Places listing claimed and matched, and a 30-day proof check — $450, one time. We sell no retainer version of either, because the work they name is finishable.

    Hold any provider’s quote — ours included — against the sections above: the inventory, the shape, the flags. The right price for this work is the one attached to finished things you own and a measurement you can repeat.

    Which lines the platforms lift is their call. We build the material they lift from — and then we measure what they did.

  • Cursor Pricing Page Now Lists Plus $8 / Premium $30 — Third-Party Models at API List

    Last refreshed: November 6, 2026 against cursor.com/pricing and cursor.com/docs/models-and-pricing.

    The live Cursor pricing page lists a new ladder. Free is limited. Plus is $8/month and includes Grok models only. Premium is $30/month with 4x Plus usage and third-party models (Claude, GPT, Gemini) billed at API list price. Super is $100/month (15x). Ultra is $200/month (50x). Teams start at $30+ per user.

    The docs page still describes older Pro $20 / Pro Plus $60 / Ultra $200 plans with separate Cursor Models and Other Models pools. Existing subscribers may keep prior plans. Quote both sources. Do not average them.

    Claude seats did not move. Pro remains $20/month or $17 annual. Max is $100 (5x Pro usage); the $200 tier is Ultra (10x Pro weekly). Claude Code is included in paid Claude plans and shares the usage pool. API list rates are unchanged: Haiku 5.5 $0.10/$0.50 under 100k prompts, Sonnet 5.5 $2/$10 with $0.10 cache reads, Opus 5.5 $4/$20.

    The split that matters for operators: to run Claude models inside Cursor you now need Premium ($30) plus API list charges on top. A Claude Pro seat is still $20 and includes Claude Code. Two products, two meters.

    Confirm live numbers on the official pages before you change a workflow. This is the plan structure on the pricing page as of October 13, 2026.