The Default Is the Bill

TL;DR.

On October 16, at TechCrunch Disrupt, Replit CEO Amjad Masad said Replit is "no longer working with Anthropic," calling it "a decision based on both cost, partnership, and performance." By the weekend he had narrowed it. Claude is still on the platform and users can still pick it. What changed is the default: "OpenAI is now our preferred partner for powering Replit Agent."

That correction is the more interesting story. TechCrunch's reasoning on why the change matters at all: most customers never touch the model picker, so whatever the default is gets most of the traffic. Replit had been a top-five Anthropic customer. A setting that most users never see decides where most of that spend goes.

• The default is a routing decision. It's the one that covers every request where nobody made a choice.
• On one cache-heavy agent turn, list prices put six plausible defaults 100x apart. GPT-6 Astra and Claude Fable 5.1 share a $10/$50 rate card, yet Astra costs 17% more on this turn because its cache reads cost 4x as much.
• If 85% of traffic sits on the default, moving it from Fable 5.1 to GPT-6.1 Sol cuts the bill 68%. Picking a default per task class cuts it 70%, and the hardest 10% of turns stay on the frontier model.
• Below, a Python script that measures how much of your bill your default decides, then reprices it under other defaults.

Replit has published no traffic split, default-share figure, contract terms or the name of its new default model. Every spend figure here uses list prices and an assumed turn profile. None of it is Replit's bill, and none of it comes from Nadir customer data.

What actually happened.

For performance, Masad cited Replit's own benchmark, where he said "Sol and Astra perform better on building vibe-coded applications from scratch." Notice the scope of that claim. It covers one task type, building an app from nothing. Replit Agent also does small edits, debugging, file reads, deploy fixes and explanations. The benchmark backs the default for one slice of traffic, and the default applies to all of it.

A default is a router with one rule.

Every LLM product has a router, even one that has never heard the word. If the code says model = DEFAULT_MODEL unless a user overrides it, that's a router with one rule: send everything to one model. Its accuracy is whatever that model's accuracy is on your hardest request, and it bills at that model's rate on your easiest one.

Defaults also stick. In behavioral economics this is about the best-replicated result there is. Johnson and Goldstein's 2003 study of organ donation found effective consent above 85% in countries where donating is the default and below 30% where you have to opt in. Auto-enrollment pushed 401(k) participation at one large US employer from under 40% to over 85% (Madrian and Shea, 2001). Model pickers work the same way. TechCrunch's whole read on the Replit news assumed it: most users keep what they're given.

So the default isn't a small setting next to the model menu. It's where most of the spend goes.

Six defaults, one turn.

Take one ordinary coding-agent turn: 60,000 input tokens, 90% served from the prompt cache, 1,200 output tokens, about what a mid-session turn costs when it re-reads repo context and writes a small diff. We used the same profile in Same $200, Half the Codex.

List prices per million tokens, October 2026. On Claude, the uncached 10% of each turn is billed as a cache write, since an agent loop caches it for the next turn. OpenAI charges no cache-write premium.

Two things stand out.

Frontier for frontier is not a saving. At list price, moving a cache-heavy default from Fable 5.1 to GPT-6 Astra raises the cost of this turn by 17%. Both models list at $10/$50, but Fable 5.1 bills cache reads at $0.25 and Astra at $1.00, and on an agent turn 90% of the input is cache reads. We measured the same gap on a 40-turn session in Fable 5.1 vs GPT-6 Astra: Same Price, 57% Apart. If a platform's cost motive for switching defaults is real, it comes from a cheaper tier, such as Sol, or from negotiated terms that list prices don't show. Replit hasn't said which OpenAI model now carries its default, and its contract terms aren't public.

Tier matters more than vendor. Fable 5.1 and Sonnet 5.5 are 4.6x apart, and both are Anthropic. Sonnet 5.5 and GPT-6.1 Sol are 10% apart. Vendor fights make headlines, but the tier is what sets the bill.

The default share is the multiplier.

Now apply that to a platform. Say it runs 10 million agent turns a month. Assume 85% of turns run on the default. That's our assumption, not Replit's number, which isn't published. The other 15% come from users who chose a model, and we leave them on Fable 5.1.

The savings from a cheaper default scale with how many people never change it:

The formula is short: savings = default share × (1 − new per-turn cost ÷ old per-turn cost). Fable 5.1 to Sol is an 80.2% per-turn cut. At 85% default share, that's 68.2% off the whole bill. Your users' habits are a term in your unit economics.

One default for everything is the blunt version.

Moving the whole default to Sol is cheap. It also sends your hardest 10% of turns, including the from-scratch builds Masad's benchmark measured, to a mid-tier model. The per-task-class policy in the table avoids that trade:

• Hard (10%): multi-file refactors, from-scratch builds, subtle bugs → Fable 5.1
• Mid (35%): ordinary feature edits and debugging → GPT-6.1 Sol
• Easy (55%): file reads, renames, test runs, lint fixes, explanations → Haiku 5.5

It costs less than Sol for everything, and the frontier model still handles the work that needs one. The split is illustrative, but the shape isn't: on most agent traffic, easy turns outnumber hard ones by a wide margin. RouteLLM found that most GPT-4 calls in its data didn't need GPT-4, and RouterArena measured how far real routers still sit from the oracle.

Two caveats keep this honest. First, the table reprices the same token counts on every model. Real models differ in verbosity and reasoning length, and in Three at $2/$10 the same task cost 10.6x more on one $2/$10 model than another. Cost per passing task is the number to compare. Second, switching models in the middle of a session throws away a warm cache. Decide the task class when the task starts, not on every turn, or price the cache switch penalty into the decision.

Tutorial: audit what your default decides.

The script below reads request logs as JSONL, one request per line. It needs the model, token counts, whether the model came from the default or from a user, and, if you have one, a task label: the endpoint, agent step or feature name. It prints how much of your spend the default controls, what the bill would be under each alternative default, and what a per-task policy would cost.

"""default_audit.py: how much of your LLM bill does the default model decide?

Reads JSONL request logs, one request per line:
  {"model": "claude-fable-5-1", "input_tokens": 60000, "cached_tokens": 54000,
   "output_tokens": 1200, "source": "default", "task": "easy"}

source is "default" when nobody picked the model, "user" when someone did.
task is optional: a label you already have (endpoint, agent step, feature).

  python default_audit.py logs.jsonl
  python default_audit.py --demo
"""
import json
import random
import sys
from collections import Counter, defaultdict

# $ per 1M tokens: fresh input, cache write, cache read, output.
# OpenAI has no cache-write surcharge, so its write price is the input price.
PRICES = {
    "claude-fable-5-1":  (10.00, 12.50, 0.25, 50.00),
    "gpt-6-astra":       (10.00, 10.00, 1.00, 50.00),
    "claude-sonnet-5-5": (2.00,  2.50,  0.10, 10.00),
    "gpt-6.1-sol":       (2.00,  2.00,  0.10, 10.00),
    "claude-haiku-5-5":  (0.10,  0.125, 0.01, 0.50),
    "gpt-6-luna":        (0.10,  0.10,  0.01, 0.50),
}

# One default per task label instead of one for everything.
POLICY = {"hard": "claude-fable-5-1", "mid": "gpt-6.1-sol", "easy": "claude-haiku-5-5"}


def cost(model, r):
    _, write, read, out = PRICES[model]
    fresh = r["input_tokens"] - r["cached_tokens"]
    # Agent loops write the fresh suffix to cache for the next turn.
    return (fresh * write + r["cached_tokens"] * read + r["output_tokens"] * out) / 1e6


def demo_rows(n=20_000, default_share=0.85, seed=7):
    rng = random.Random(seed)
    for _ in range(n):
        task = rng.choices(["easy", "mid", "hard"], [0.55, 0.35, 0.10])[0]
        inp = 60_000
        yield {
            "model": "claude-fable-5-1",
            "input_tokens": inp,
            "cached_tokens": int(inp * 0.9),
            "output_tokens": 1_200,
            "source": "default" if rng.random() < default_share else "user",
            "task": task,
        }


def main():
    if sys.argv[1:] == ["--demo"]:
        rows = list(demo_rows())
    else:
        with open(sys.argv[1]) as f:
            rows = [json.loads(line) for line in f if line.strip()]

    spend = defaultdict(float)
    count = Counter()
    for r in rows:
        spend[r["source"]] += cost(r["model"], r)
        count[r["source"]] += 1
    total = sum(spend.values())

    print(f"{len(rows):,} requests, ${total:,.2f}")
    for src in ("default", "user"):
        print(f"  {src:<8} {count[src] / len(rows):6.1%} of requests"
              f"  {spend[src] / total:6.1%} of spend")

    user_spend = spend["user"]
    defaults = [r for r in rows if r["source"] == "default"]

    print("\nIf the default had been ... (user picks unchanged)")
    for model in PRICES:
        new = user_spend + sum(cost(model, r) for r in defaults)
        print(f"  {model:<18} ${new:>10,.2f}  {new / total - 1:+7.1%}")

    if all("task" in r for r in defaults):
        new = user_spend + sum(cost(POLICY[r["task"]], r) for r in defaults)
        print(f"  {'per-task policy':<18} ${new:>10,.2f}  {new / total - 1:+7.1%}")
        mix = Counter(r["task"] for r in defaults)
        print("  policy: " + ", ".join(
            f"{t} {mix[t] / len(defaults):.0%} -> {m}" for t, m in POLICY.items()))


if __name__ == "__main__":
    main()

The --demo run uses the synthetic platform from the tables above:

20,000 requests, $2,970.00
  default   85.0% of requests   85.0% of spend
  user      15.0% of requests   15.0% of spend

If the default had been ... (user picks unchanged)
  claude-fable-5-1   $  2,970.00    +0.0%
  gpt-6-astra        $  3,403.45   +14.6%
  claude-sonnet-5-5  $    996.53   -66.4%
  gpt-6.1-sol        $    945.54   -68.2%
  claude-haiku-5-5   $    477.92   -83.9%
  gpt-6-luna         $    475.37   -84.0%
  per-task policy    $    888.29   -70.1%
  policy: hard 10% -> claude-fable-5-1, mid 35% -> gpt-6.1-sol, easy 55% -> claude-haiku-5-5

How to use it on real traffic:

1. Log the source. Most apps don't record whether the model came from the default or from a user choice. Add one field. Without it you can't tell a default problem from a power-user problem.
2. Use labels you already have. Endpoint names, agent step types and feature flags make fine task classes for a first pass. You don't need a classifier to find out that your "explain this file" endpoint runs on the flagship.
3. Treat the what-if rows as an upper bound. They reprice the same tokens. Before you change anything, replay a sample of each class on the candidate model and compare pass rates, the way we laid out in shadow testing a model swap.
4. Keep the picker. Replit kept Claude available, and that was the right call. Users who choose explicitly know what they need, and overriding them costs trust that a cheaper bill won't win back.

A checklist before you flip the default.

• Price the whole turn, not the rate card. Include cache reads, cache writes and output length. A switch between two models at the same list price moved this turn's cost 17%.
• Check the API surface. New model versions sometimes break old request shapes. Sonnet 5.5 returned 400s on parameters older code still sent. Replay real requests first.
• Expect a cold cache. Every active session loses its cache the moment the default changes. The first day after a switch costs more than the steady state.
• Stage it. Move one task class at a time and watch cost per resolved task, not cost per token.
• Plan for the next switch. Replit's default has changed once in public this year. One price tracker logged 17 list-price moves in a single report this month. If changing the default means a deploy, a vendor negotiation and a press cycle, you'll do it rarely and late.

Where Nadir fits.

A default chosen once a quarter is the slowest router you can run. Nadir makes the default a decision per request. Point your OpenAI compatible base URL at Nadir and send model="auto". Each request goes to the cheapest model in your configured set that clears the quality floor you set per API key. Requests that name a model still get that model, so the picker keeps working.

Because the default becomes a policy rather than one model name, the next vendor change is a config edit, not a migration. Every response reports which model answered and what it cost, which gives you the source and cost columns this tutorial needs.

To measure before you change anything, run a week in Observe mode. It serves exactly the model you asked for and records what routing would have chosen, so you get your own default share and your own task mix instead of our 85% and 55/35/10. Savings vary with your workload, and the synthetic figures here are not a forecast of yours.

Start with a free key, or see how routing works.

Conclusion.

The Replit story reads like a breakup, but what actually happened is a default change. Claude stayed on the platform. The model that serves everyone who didn't choose changed, and for a platform where most people don't choose, that's most of the bill. The arithmetic is the same for any team: savings equal default share times the per-turn gap. Swapping one frontier model for another at the same list price can raise the bill. Most of the money is in the easy work your default sends to the flagship. Measure what your default decides, then give it more than one rule.

Spend figures are illustrative: list prices from provider pricing pages as of October 2026, an assumed turn profile (60,000 input tokens, 90% cached, 1,200 output), an assumed 85% default share and an assumed 55/35/10 task mix. They are not Replit's costs and are not derived from customer data. Sources: [TechCrunch, "Replit makes OpenAI its default over Anthropic, CEO says," October 17, 2026](https://techcrunch.com/2026/10/17/replit-is-no-longer-working-with-anthropic-ceo-says/) (Masad's quotes, top-five customer, most customers keep the default, the disputed partnership status). [Tech Insider, "Replit's Anthropic Breakup Claim Folds in 24 Hours"](https://tech-insider.org/replit-anthropic-openai-walkback-2026/) (timeline and clarification quotes). [Under30CEO, "LLM API Pricing Climbs as Alibaba Lifts DeepSeek Rates," October 22, 2026](https://under30ceo.com/llm-api-pricing-alibaba-deepseek-rates) (17 price moves in Stork AI's October 20 report). Johnson, E. J. and Goldstein, D. G., "Do Defaults Save Lives?", Science, 2003. Madrian, B. C. and Shea, D. F., "The Power of Suggestion: Inertia in 401(k) Participation and Savings Behavior," Quarterly Journal of Economics, 2001. Model prices from our earlier posts on [Haiku 5.5](/blog/claude-haiku-5-5-pricing-100k-cliff-tokenizer-effort), [GPT-6 Sol and Luna](/blog/gpt-6-sol-luna-pricing-terra-retired-routing) and [Fable 5.1 vs Astra](/blog/same-sticker-different-bill-cache-read-pricing-fable-astra).