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.
- A daily cap is a quantity limit, not a price. What $200 buys depends on which model spends it. In our illustrative model, $200 is 111 agent tasks a day on Claude Opus 5.5 and 229 on a routed mix that still sends a quarter of its tokens to Opus.
- Caps bind the tail, not the median. Bloomberg's sources said few workers used their full $300. In our model, 3.3% of engineer-days reach $300 and 7.2% reach $200, but 20% reach $100. Most of the "savings" from the first cut is small. The cut to $100 is the one people will feel.
- Blocked work isn't savings. A hard stop at $100 removes 33% of spend in our model, and every one of those dollars was a task that didn't run. Routing the same work to the cheapest model that can do it lowered spend 52% with nothing blocked.
- Below is capfit.py, about 70 lines of Python that read your per-user usage log and tell you, for each candidate cap, how many user-days hit it, how many dollars a hard stop would block, and what happens if frontier traffic downgrades at half the cap instead.
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.
| Before | After (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 cap | Exemption from a senior executive | |
| What it meters | Tokens 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 task | Tasks at $25 | Tasks at $100 | Tasks at $200 | Tasks at $300 |
|---|---|---|---|---|---|---|
| Claude Opus 5.5 | $0.900 | $1.80 | 13 | 55 | 111 | 166 |
| Claude Sonnet 5.5 | $0.450 | $0.90 | 27 | 111 | 222 | 333 |
| Routed mix | $0.436 | $0.87 | 28 | 114 | 229 | 344 |
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.
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.
| Daily cap | Days that hit it, Opus default | Spend a hard stop removes | Days that hit it, routed mix |
|---|---|---|---|
| $300 | 3.3% | 9.5% | 0.6% |
| $200 | 7.2% | 16.2% | 1.7% |
| $100 | 20.2% | 32.9% | 6.8% |
| $25 | 66.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 cap | What the engineer sees | What it costs | Who it suits |
|---|---|---|---|
| Hard stop | Requests fail until tomorrow | Blocked work, context lost mid-task | Non-engineering teams with light, bursty use |
| Exemption | A request to an executive, then a wait | Executive time, a stalled afternoon | Rare outliers you want to see by name |
| Soft limit, then downgrade | Frontier requests drop to a cheaper model past a threshold | Some quality risk on hard steps | Engineering 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:
- hit is the share of user-days that reach the cap under a hard stop. At $100, one day in five.
- blocked is the share of total spend a hard stop refuses. That's work, not savings, so look at it next to how many engineers it lands on.
- soft hit and soft spend replay the same days with frontier calls moving to Sonnet 5.5 past half the cap, with the hard stop still in place. At $100, the share of days that reach the cap falls from 19.9% to 11.2%, and spend lands at 64% of the uncapped total.
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.
- Nobody is near the cap. If your 95th-percentile day is well under the limit, a cap is a guardrail against runaway loops or a stolen key, not a cost control. Set it high and alert on it.
- Your engineers are on seat plans. If they use Claude Code or Codex on a flat subscription, the vendor meters them and you pay per seat. Your lever is which plan you buy, not a daily dollar cap.
- The expensive days are the valuable ones. If the $300 days are your on-call engineers fixing production, a cap that stops them is the wrong tool. Exempt the role, not the request.
- The spend is outside your gateway. A cap only covers tools that go through it. If teams use personal accounts, a tight cap pushes more usage there. That's the shadow AI problem, and it gets worse as caps get tighter.
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.