The Flat Quarter

TL;DR.

On October 12, SpaceX Super Intelligence folded Grok, Cursor, and X Premium into one plan, The X Subscription. Most coverage was about the bundle. The line that matters for engineering budgets is in Cursor's team pricing docs: on Teams and Enterprise plans, every third-party model request now carries a Cursor Token Rate of $0.25 per million tokens, on top of the model's API price.

Three details make it bigger than it sounds:

• It counts every token. Cursor says it "applies to input tokens, output tokens, and cached tokens." Coding agents send most of their tokens as cache reads, which are the cheapest tokens on any rate card. A flat fee lands hardest on them.
• It applies to BYOK. Bringing your own Anthropic or OpenAI key doesn't avoid it.
• Cursor's own models are exempt. Grok and Composer don't pay it, and neither does Cursor Router's Cost mode.

Because the fee is per token rather than a percentage, it's regressive. On an illustrative agent token mix it adds 8% to Claude Fable 5.1, 39% to Claude Sonnet 5.5, and 690% to Claude Haiku 5.5. It flips the price ranking toward Cursor's house models, and it takes 28% of every dollar you'd save by routing Sonnet traffic to Haiku.

This post covers:

• What changed, from Cursor's own docs
• Why a per-token fee hits cheap models and cached tokens hardest
• How it reorders the model menu and shrinks routing savings
• A Python tutorial: price models with platform fees included, re-rank them for your own token mix, and estimate the monthly Token Rate per engineer
• What to do about it

Prices are Cursor's published list prices as of October 15, 2026. The token mix and the per-engineer usage are illustrative and labeled where they appear. Nothing here is Nadir customer data.

What changed.

The X Subscription has five tiers: Free, Plus at $8, Premium at $30, Super at $100, and Ultra at $200 a month. Paid plans share one weekly usage pool across Grok, Grok Bot, and Cursor. That pool covers Cursor's models only: Grok 4.7, 4.6, 4.5, and Composer 2.5. Third-party models from Anthropic, OpenAI, Google, Z.ai, Moonshot, and Meta start at Premium and bill outside the pool, from prepaid credit.

Seats don't share pools, and usage doesn't transfer between team members. Third-party usage and anything past a seat's pool comes out of one shared prepaid balance, capped by a monthly team limit an admin sets. Teams created before The X Subscription keep the old Standard ($40) and Premium ($120) seats.

None of this is hidden. It's on the Teams pricing and models and pricing pages. But the dashboard most teams look at reports spend in dollars per model, and Cursor's usage page has a history of changing what it shows. A $0.25 fee per million tokens is easy to read as a rounding error. On the models and meters coding agents actually use, it isn't.

A flat fee is a regressive fee.

A percentage markup scales with the price of the model. A flat per-token fee doesn't, so the cheaper the model, the bigger the fee is in percentage terms.

To price it, take one million tokens of agent traffic with the mix we used for agent rereading costs: 85% cache reads, 3% cache writes, 9% fresh input, 3% output. Price it at Cursor's listed rates, then add the Token Rate.

At list price, the spread from Haiku 5.5 to Fable 5.1 is 82x. With the Token Rate it's 11x. Every model now has a floor of $0.25 per million tokens before the model costs anything.

The fee lands on the cache.

The most important number in the Cursor docs is the word "cached." Cache reads are where coding agents spend most of their tokens and where providers give the steepest discount. A flat fee on top of a discounted price undoes most of the discount.

A Haiku 5.5 cache read lists at a penny per million tokens. On Cursor Teams it costs 26 cents. A Sonnet 5.5 cache read goes from $0.10 to $0.35, which is more than Composer 2.5's cache read and 70% of Grok 4.7's. Anthropic prices cache reads at a tenth of input so long agent sessions stay affordable. On this surface, most of that discount is gone.

That changes which optimizations pay off. Raising your cache hit rate still helps, because a cache read still costs less than fresh input. But each point of cache share is worth much less than on the direct API, because the fee doesn't care whether a token was cached. The cheapest thing a third-party token can cost on Cursor Teams is $0.25 per million.

The ranking flips toward the house.

Sort the models by cost per agent token at list price, and Cursor's models sit in the middle. Composer 2.5 costs 4x to 8x what Haiku 5.5, Luna, or GLM Flash cost, and Grok 4.7 costs 32% more than Sonnet 5.5.

Add the fee and the order changes:

• Composer 2.5 now undercuts GPT-5.6 Luna and GLM 5.3 Flash, and sits within 7% of Haiku 5.5.
• Grok 4.7 now undercuts Claude Sonnet 5.5 and Gemini 4 Argon, at $0.845 against $0.890 and $0.875.

Whether Composer or Grok can do your work as well as Sonnet or Haiku is a quality question this table doesn't answer. But a developer, or an automatic router, that picks by price now sees the house models win comparisons they lost a week ago. In June we wrote about coding tools moving from flat plans to metered billing. A per-token fee with a first-party exemption goes a step further: the meter itself steers you toward the house models.

The routing win shrinks by 28%.

Routing works because the price gap between models is wide. Send the turns that don't need a frontier model to a small one, and you save most of the difference. A flat fee narrows every gap, so it shrinks every routing win.

The loss is the same 28% in every row, and that's not a coincidence. The dollars saved per routed token don't change, since the fee is charged on both models. What changes is the baseline, which grows from $0.64 to $0.89. The share of the win you keep is the baseline price over the baseline plus the fee: $0.64 / $0.89, or 72%. Against a Fable 5.1 baseline you'd keep 92%. Against a Haiku-class baseline, almost nothing is left to route for.

One caveat from the same docs: Haiku 5.5 bills at 5x when a request carries more than 100K input tokens, which long agent sessions reach. We covered that cliff last week. The numbers above assume requests stay under it.

BYOK is not an exit.

The usual way to control third-party spend in an IDE is to bring your own key: your contract, your rate limits, your invoice. On Cursor Teams that still works for the model bill, but the Token Rate rides along. With BYOK you pay Anthropic or OpenAI for the model, and Cursor $0.25 per million for every token sent through it.

So the size of the fee depends on volume, not on your model contract. For an illustrative heavy agent user who sends 500 million third-party tokens a month, mostly cache reads on Sonnet, it comes to $125 a month. That's more than a $100 Super seat, and about half of the $260 the same tokens cost at the models' list prices.

Tutorial: price the platform, not just the model.

Most LLM cost tooling stores one price per model. That breaks as soon as the same model costs different amounts on different surfaces. The fix is a small model of the bill: per-meter model rates, plus a platform layer that can add a flat per-token fee, a percentage uplift, or both.

Step 1: one function for every surface.

from dataclasses import dataclass

@dataclass(frozen=True)
class Rates:
    """USD per million tokens. write=None means writes bill at input rate."""
    fresh: float
    cache_read: float
    output: float
    write: float | None = None

@dataclass(frozen=True)
class Platform:
    per_token: float = 0.0   # flat USD per million, on every meter
    uplift: float = 0.0      # percentage on the model price, e.g. 0.10

def per_million(r: Rates, mix: dict, p: Platform = Platform()) -> float:
    """Cost of one million tokens with this meter mix, platform fees included."""
    write = r.fresh if r.write is None else r.write
    model = (mix["fresh"] * r.fresh + mix["cache_read"] * r.cache_read
             + mix["write"] * write + mix["output"] * r.output)
    return model * (1 + p.uplift) + p.per_token

per_token covers fees like the Cursor Token Rate. uplift covers percentage surcharges: Cursor lists a 10% uplift for data residency, and 20% for Max Mode on legacy plans. Gateways and marketplaces each have their own version.

Step 2: describe the catalog and the surfaces.

CATALOG = {  # Cursor's published list prices, October 2026
    "claude-haiku-5.5":  (Rates(0.10, 0.01, 0.50, 0.125), "third_party"),
    "gpt-5.6-luna":      (Rates(0.20, 0.02, 1.20, 0.25),  "third_party"),
    "composer-2.5":      (Rates(0.50, 0.20, 2.50),        "cursor"),
    "gemini-4-argon":    (Rates(2.00, 0.10, 10.00),       "third_party"),
    "claude-sonnet-5.5": (Rates(2.00, 0.10, 10.00, 2.50), "third_party"),
    "grok-4.7":          (Rates(2.00, 0.50, 6.00),        "cursor"),
    "claude-opus-5.5":   (Rates(4.00, 0.20, 20.00, 5.00), "third_party"),
}

SURFACES = {
    "api_direct":   {"third_party": Platform(),               "cursor": None},
    "cursor_teams": {"third_party": Platform(per_token=0.25), "cursor": Platform()},
}

def rank(mix: dict, surface: str):
    rows = []
    for name, (rates, owner) in CATALOG.items():
        p = SURFACES[surface][owner]
        if p is not None:
            rows.append((per_million(rates, mix, p), name))
    return sorted(rows)

None marks a model that isn't available on a surface: Composer and Grok's Cursor pricing only applies inside Cursor.

Step 3: rank for your own mix.

AGENT = {"fresh": 0.09, "cache_read": 0.85, "write": 0.03, "output": 0.03}
for surface in SURFACES:
    print(surface)
    for usd, name in rank(AGENT, surface):
        print(f"  {name:<18} ${usd:.3f}")

api_direct
  claude-haiku-5.5   $0.036
  gpt-5.6-luna       $0.079
  gemini-4-argon     $0.625
  claude-sonnet-5.5  $0.640
  claude-opus-5.5    $1.280
cursor_teams
  claude-haiku-5.5   $0.286
  composer-2.5       $0.305
  gpt-5.6-luna       $0.329
  grok-4.7           $0.845
  gemini-4-argon     $0.875
  claude-sonnet-5.5  $0.890
  claude-opus-5.5    $1.530

Replace AGENT with your real mix. The four-meter tutorial shows how to compute it from the usage fields OpenAI, Anthropic, and Gemini already return. The more cache-heavy your traffic, the more a flat fee reorders the list. A chat workload with little caching barely moves.

Step 4: put a number on the fee.

def monthly_fee(rows, per_token=0.25):
    """rows: (model, owner, fresh, cache_read, write, output) token counts."""
    total = 0.0
    for model, owner, *meters in rows:
        if owner == "third_party":
            total += sum(meters) * per_token / 1e6
    return total

usage = [  # one engineer, one month (illustrative)
    ("claude-sonnet-5.5", "third_party", 36e6, 340e6, 12e6, 12e6),
    ("claude-haiku-5.5",  "third_party",  9e6,  85e6,  3e6,  3e6),
    ("composer-2.5",      "cursor",      18e6, 170e6,  6e6,  6e6),
]
print(f"Token Rate: ${monthly_fee(usage):,.2f} per engineer per month")

Token Rate: $125.00 per engineer per month

Run it on your team's usage export before the next seat renewal. It's the number to bring to an Enterprise negotiation, and the number to compare with what the same agents would cost outside the IDE.

What to do about it.

1. Measure before you react. For a team that mostly chats with Sonnet or Opus and caches little, the fee is a few percent. For a team running long agent sessions on small models, it can be the largest line on the bill. The tutorial tells you which one you are.
2. Keep IDE work on the models where the fee is small. For interactive coding on frontier models, the Token Rate adds 8% to 20% on our illustrative mix. That's a platform fee you may well decide is worth it.
3. Move high-volume, cache-heavy, small-model work off the surface. CI agents, batch refactors, test generation, and background jobs that run for hours on a cheap model are where a flat fee multiplies the cost the most. Run them against the provider APIs, where a cache read is a penny again.
4. Re-evaluate the house models on quality, not on the new price ranking. If Composer or Grok does your work well enough, the exemption is a real saving. If not, the cheaper sticker costs more in retries and review.
5. Fix your price tables. Any router, budget alert, or dashboard that uses one price per model now gets Cursor traffic wrong. Price per surface and per meter.

Where Nadir fits.

Nadir is a cost router for LLM traffic you send through an API: your agents, pipelines, and backend calls. It doesn't sit inside Cursor, and pointing Cursor at another endpoint wouldn't remove the Token Rate, since it applies to BYOK.

Where it helps is step 3. With model="auto", a trained classifier reads each request and sends it to the cheapest model you've configured that can handle it, against the quality floor you set on the key. Moving a background agent from the IDE to the API and routing its easy turns to a small model gets you the full list-price gap from the chart above, not the 72% that survives a flat fee. The decision endpoint also accepts an optional cache_state and weighs a warm prompt cache before switching models, so routing doesn't throw away the cache reads that make agents affordable in the first place.

Nadir also prices the other way around. There is no per-token platform fee. With your own keys, you pay 25% of the first $2,000 of measured monthly savings and 10% above that, so if routing saves you nothing, it costs you nothing. You can start in Observe mode, which records the decision Nadir would make on each request without changing any response. Start with a free key, or put your own token mix into the savings calculator.

Conclusion.

The X Subscription is a bundle story, but the line that will move engineering budgets is a quarter per million tokens. Because it's flat, it barely touches frontier models and multiplies the cost of the cheap ones. Because it counts cached tokens, it lands hardest on agents. Because Cursor's own models are exempt, it tilts every price comparison toward them. None of that makes Cursor a bad deal for interactive coding. It does mean the cheapest model for a task now depends on where you call it from. Price the platform along with the model, and move the high-volume work to wherever the discounts still reach you.

Sources: [Cursor Teams pricing](https://cursor.com/docs/account/teams/pricing) for the Cursor Token Rate, its scope (input, output, and cached tokens; BYOK included; Cost mode and Cursor models exempt), seat prices, and pool rules; [Cursor models and pricing](https://cursor.com/docs/models-and-pricing) for plan tiers, the pool's models, Cursor and third-party per-token prices, the Haiku 5.5 100K threshold, the data residency uplift, and Max Mode pricing, both read October 15, 2026; [TechCrunch](https://techcrunch.com/2026/10/13/spacexsi-bundles-x-premium-grok-and-cursor-into-one-subscription/), October 13, 2026, and [the xAI announcement](https://x.ai/news/x-subscription) for The X Subscription tiers and rollout. Found via [Implicator.ai's LLM Meter](https://implicator.ai/llm-meter-week-of-oct-13-2026), week of October 13, 2026. The agent token mix (85% cache reads, 3% cache writes, 9% fresh input, 3% output) and the per-engineer usage are illustrative, and the tutorial output is computed from them, not from Nadir customer data.