The $200 Day

Apple reportedly cut some engineers' daily AI budgets from $300 to $200, with $100 under consideration and $25 for some non-engineering teams. A daily cap is a quantity limit, not a price: in our illustrative model, $200 buys 111 agent tasks on Claude Opus 5.5 and 229 on a routed mix. Caps bind the tail, and blocked work isn't savings. Includes capfit.py, which replays your per-user usage against candidate caps and a soft downgrade limit.

Published 2026-11-07 by Dor Amir on the Nadir blog.

Filed under FinOps & Governance.

TL;DR.

On November 4, Reuters, citing Bloomberg, reported that Apple has cut its employees' daily AI budgets. Some engineers went from $300 a day to $200 in October, and Apple is weighing a further cut to $100. Many non-engineering groups already sit at $100 a day, and some teams could drop to $25. Staff who need more can ask a senior executive for an exemption. Bloomberg also reported that Goldman Sachs restricted some AI coding tools after a review. Per-person token budgets have arrived at the biggest companies, and the rest will follow.

Apple figures are from Reuters' November 4, 2026 report of a Bloomberg story citing people familiar with the matter, and from Macworld's November 5 summary. Apple didn't comment. Prices are Anthropic list prices retrieved November 7, 2026. The task and engineer-day models are ours and illustrative. No figure here comes from Apple's or any Nadir customer's usage data.

What Apple changed.

BeforeAfter (reported)
Engineers, daily AI cap$300$200 since October, $100 under consideration
Non-engineering groups, daily cap$100$100, as low as $25 for some teams
Over the capExemption from a senior executive
What it metersTokens across providers such as ChatGPT, Claude, and Gemini

Three details matter more than the dollar amounts.

It's per person, per day. That's not a department budget or a monthly invoice someone reviews after the fact. It's an allowance attached to an identity that resets every morning. It's the same shape as the weekly allowances on Codex and Claude plans, now set by the employer instead of the vendor.

It's counted in dollars, not tokens. A $200 cap is a different number of tokens on every model. An engineer who points an agent at Opus 5.5 reaches it about 30x sooner than one running the same calls on Haiku 5.5.

The first cut was cheap on purpose. Bloomberg's sources said few people used the full $300 allowance, so the drop to $200 mostly removed headroom nobody was using. Apple just had what it calls its best fiscal year, so this reads less like an emergency than like a company putting a price on a habit before it grows. Uber spent its 2026 AI budget in four months. Apple is setting the limit first.

What $200 a day buys.

To make the caps concrete, we priced one coding agent task. A task is 2 million tokens: 90% cache reads, 8% fresh input, and 2% output, which is a normal shape for a cached agent loop of a few dozen turns. At Anthropic list prices:

Model$ / M blended$ per taskTasks at $25Tasks at $100Tasks at $200Tasks at $300
Claude Opus 5.5$0.900$1.801355111166
Claude Sonnet 5.5$0.450$0.9027111222333
Routed mix$0.436$0.8728114229344

The routed mix is 25% of tokens on Opus 5.5, 45% on Sonnet 5.5, and 30% on Haiku 5.5. It still sends the hardest quarter of the work to the top model, and it doubles what a cap buys.

Grouped bar chart of agent tasks per engineer per day at four daily caps, always Claude Opus 5.5 against a routed mix. $25: 13 against 28 tasks. $100: 55 against 114. $200: 111 against 229. $300: 166 against 344. One task is 2M tokens at 90% cache reads, 8% fresh input and 2% output.
Grouped bar chart of agent tasks per engineer per day at four daily caps, always Claude Opus 5.5 against a routed mix. $25: 13 against 28 tasks. $100: 55 against 114. $200: 111 against 229. $300: 166 against 344. One task is 2M tokens at 90% cache reads, 8% fresh input and 2% output.

Read the table the other way and it says something uncomfortable. An engineer on a routed mix at $100 a day gets slightly more done than one on always-Opus at $200. If Apple's next cut to $100 lands on teams whose tools default to the top model, it halves their agent throughput. The same cut on a routed mix costs them almost nothing.

Who hits the cap.

A cap only matters on the days someone reaches it. To see where each level bites, we modeled engineer-days as lognormal, with a median day of $40 and a mean of $73 on an Opus default. That's a typical spend curve: most days are modest, and a few long debugging or migration days are very expensive.

Grouped bar chart of the share of engineer-days that reach each daily cap, Opus 5.5 by default against a routed mix doing the same work. $300: 3.3% against 0.6%. $200: 7.2% against 1.7%. $100: 20.2% against 6.8%. $25: 66.5% against 40.8%. Illustrative lognormal model with a median day of $40.
Grouped bar chart of the share of engineer-days that reach each daily cap, Opus 5.5 by default against a routed mix doing the same work. $300: 3.3% against 0.6%. $200: 7.2% against 1.7%. $100: 20.2% against 6.8%. $25: 66.5% against 40.8%. Illustrative lognormal model with a median day of $40.
Daily capDays that hit it, Opus defaultSpend a hard stop removesDays that hit it, routed mix
$3003.3%9.5%0.6%
$2007.2%16.2%1.7%
$10020.2%32.9%6.8%
$2566.5%71.0%40.8%

Two things stand out.

The cut from $300 to $200 is mostly symbolic. It moves the share of days that hit the cap from about 3% to 7%. That fits the reporting that few people used the full allowance.

$100 is where caps start doing the work of a budget. One engineer-day in five reaches it. The "spend a hard stop removes" column looks like savings, but it's work that didn't happen: the long debugging session that stopped halfway, the migration that waits until tomorrow, the exemption request a senior executive has to read. A cap that removes a third of spend by refusing a third of the work hasn't cut cost, it has cut output.

A routed mix lowers total spend by 52% in this model without refusing anything, and it pushes the share of days that reach $100 from 20% down to 7%. Routing and caps aren't alternatives. Routing makes the cap something only the real outliers see.

Three ways to handle the cap.

When an engineer reaches the limit at 3 p.m., something has to happen. There are three options, and most companies only build the first.

At the capWhat the engineer seesWhat it costsWho it suits
Hard stopRequests fail until tomorrowBlocked work, context lost mid-taskNon-engineering teams with light, bursty use
ExemptionA request to an executive, then a waitExecutive time, a stalled afternoonRare outliers you want to see by name
Soft limit, then downgradeFrontier requests drop to a cheaper model past a thresholdSome quality risk on hard stepsEngineering teams running agents all day

The soft limit is the one worth building. Past a threshold, say half the cap, frontier requests go to the next tier down instead of failing. The engineer keeps working, the hardest steps still get a strong model until the threshold, and the hard stop stays as a backstop. We covered the time dimension of this, spending a budget evenly across a month, in Budget Bankruptcy. A daily cap is the same problem on a one-day clock.

Two cautions. Downgrading mid-session invalidates the prompt cache, so a switch can cost more on the next turn than it saves. Do it at task boundaries, as covered in Your Router Is Fighting Your Prompt Cache. And a downgrade should be visible to the engineer, in a response header or a status line, so a weaker answer isn't a mystery.

Tutorial: capfit.py.

Before you pick a number for your own teams, replay your own usage against it. capfit.py reads one row per user, day, and model and answers three questions for each candidate cap: how many user-days reach it, how many dollars a hard stop would block, and how both numbers change with a soft limit that moves frontier traffic to a cheaper model at half the cap.

Export usage from your gateway or provider console with user,date,model,input,cache_read,output columns, one row per call or per session, in the order they happened. If you don't have a user column yet, the chargeback tutorial shows how to tag requests so you do. Any model missing from PRICES raises an error, so nothing gets priced at zero.

"""capfit.py: what would a daily AI cap per engineer actually do?

Reads one CSV row per user, day, and model (fresh input, cache read, and
output tokens), prices it, and for each candidate cap prints how many
user-days hit it and how many dollars a hard stop would block. Then it
replays the same days with a soft limit: past SOFT of the cap, frontier
tokens are billed at the fallback model's rates instead of being refused.
Unknown models raise, so nothing is priced at $0.
"""
import csv
import sys
from collections import defaultdict

# $ per million tokens: fresh input, cache read, output. Edit to your rate card.
PRICES = {
    "claude-opus-5-5":   (4.00, 0.20, 20.00),
    "claude-sonnet-5-5": (2.00, 0.10, 10.00),
    "claude-haiku-5-5":  (0.10, 0.01, 0.50),
}
FRONTIER = {"claude-opus-5-5"}
FALLBACK = "claude-sonnet-5-5"
CAPS = [300, 200, 100, 25]
SOFT = 0.5  # downgrade frontier traffic once a day passes half its cap


def cost(model, inp, cache, out):
    if model not in PRICES:
        raise KeyError(f"no price for {model!r}; add it to PRICES")
    p_in, p_cache, p_out = PRICES[model]
    return (inp * p_in + cache * p_cache + out * p_out) / 1e6


def load(path):
    days = defaultdict(list)  # (user, date) -> [(model, inp, cache, out)]
    with open(path, newline="") as f:
        for r in csv.DictReader(f):
            row = (r["model"], int(r["input"]), int(r["cache_read"]), int(r["output"]))
            days[(r["user"], r["date"])].append(row)
    return days


def soft_day(rows, cap):
    """Spend for one day when frontier rows past SOFT*cap bill as FALLBACK."""
    spent = 0.0
    for model, inp, cache, out in rows:  # rows in the order they were logged
        if model in FRONTIER and spent >= SOFT * cap:
            model = FALLBACK
        spent += cost(model, inp, cache, out)
    return spent


def main(path):
    days = load(path)
    raw = {k: sum(cost(*r) for r in rows) for k, rows in days.items()}
    total = sum(raw.values())
    n = len(raw)
    print(f"{n} user-days  ${total:,.0f}  median ${sorted(raw.values())[n // 2]:,.0f}/day")
    print(f"{'cap':>5} {'hit':>6} {'blocked':>9} | {'soft hit':>8} {'soft spend':>11}")
    for cap in CAPS:
        hit = sum(v > cap for v in raw.values())
        blocked = sum(max(0.0, v - cap) for v in raw.values())
        soft = {k: soft_day(rows, cap) for k, rows in days.items()}
        soft_hit = sum(v > cap for v in soft.values())
        soft_total = sum(min(v, cap) for v in soft.values())
        print(f"${cap:>4} {hit / n:>6.1%} {blocked / total:>9.1%} | "
              f"{soft_hit / n:>8.1%} {soft_total / total:>11.1%}")


if __name__ == "__main__":
    main(sys.argv[1] if len(sys.argv) > 1 else "usage.csv")

Here it is on a synthetic file: 200 engineers over 20 working days, all on Opus 5.5, with daily spend drawn from the same lognormal curve as the chart above.

$ python capfit.py usage.csv
4000 user-days  $285,957  median $41/day
  cap    hit   blocked | soft hit  soft spend
$ 300   2.8%      7.9% |     1.1%       87.8%
$ 200   6.8%     14.3% |     2.8%       80.7%
$ 100  19.9%     30.8% |    11.2%       64.2%
$  25  67.6%     70.0% |    53.2%       28.5%

How to read it:

The soft limit in this script only changes the price of each call. It doesn't model the quality change, and on the hardest tasks a cheaper model may need more turns or fail. Before you roll a downgrade rule out to a team, run the downgraded calls through your own evals.

Two extensions worth adding. Group the output by team, since a $100 cap means something different to a platform team than to a design team. And print the top ten user-days by spend: those are the people who'd file exemptions, and you'd want to talk to them before the cap ships, not after.

When not to bother.

Where Nadir fits.

capfit.py tells you what a cap would do to your teams. Nadir is a way to make the same cap buy more.

Route per request, under one endpoint. Point your OpenAI or Anthropic client at Nadir's gateway and set model="auto". A trained classifier sends each request to the cheapest model you've allowed that clears your quality floor, so a dollar cap stretches further without anyone choosing a model by hand.

Per-key limits and per-request cost. Give each engineer or team their own API key and attach a quality floor and model allowlist to it. Every response reports the model that served it and what it cost, so the user, model, and token columns capfit.py needs come straight from your own logs.

Measure before you change anything. Observe mode serves exactly the model you asked for and records what routing would have chosen. Run it for a week and replay the result through capfit.py to see how many of your cap-hitting days routing would have avoided. With your own provider keys, the provider bills you directly, and Nadir charges a flat $0.002 per request, with the first 50 requests a month free. Savings depend on your workload, and nothing in this post forecasts yours.

Start with a free key, or estimate your savings from your current model spend.

Conclusion.

Apple's caps are a sign of where enterprise AI is going in 2027. The question is moving from "should people use AI" to "how much AI does a person get each day," and the answer is going to be a dollar figure set by finance. That number only means something once you know which model spends it. On an always-frontier default, a $100 cap halves an engineer's agent throughput. On a routed mix, it barely registers, and the people who still hit it are the ones you'd want to talk to anyway. Set the cap, but route first, and replay your own usage before you pick the number.


Sources: [Reuters via Investing.com, "Apple cuts employee AI budgets in cost-control push, Bloomberg News reports," November 4, 2026](https://www.investing.com/news/stock-market-news/apple-cuts-employee-ai-budgets-in-costcontrol-push-bloomberg-news-reports-5001149). [Macworld, "Apple reportedly slashes employee AI usage limits amid 'cost-cutting effort'," November 5, 2026](https://www.macworld.com/article/3277678/apple-reportedly-slashes-employee-ai-usage-limits-amid-cost-cutting-effort.html). [Anthropic, Pricing](https://platform.claude.com/docs/en/about-claude/pricing), retrieved November 7, 2026: Opus 5.5 $4 input, $0.20 cache read, $20 output. Sonnet 5.5 $2, $0.10, $10. Haiku 5.5 $0.10, $0.01, $0.50, per million tokens. The task model (2M tokens at 90% cache reads, 8% fresh input, 2% output), the routed mix (25% Opus, 45% Sonnet, 30% Haiku by tokens), and the engineer-day model (lognormal, median $40, sigma 1.1) are ours and illustrative.

More on finops & governance

Pages on this site

Machine-readable summaries of this site: llms.txt and llms-full.txt.