TL;DR.
Bloomberg reported on November 4 that Apple has cut the daily AI spending cap for some of its engineers from $300 to $200, with some allowances expected to fall to $100. Teams outside engineering, many already at $100 a day, could go as low as $25. In the same story, two details matter more than the caps: Apple is asking some teams to use less expensive models or on-device AI, and employees said few people ever used their full $300.
Put those two details together and you get the economics of every daily cap.
- A cap only bills the days above it. In our synthetic month of 1,000 engineers, 0.7% of engineer-days go over $300. Capping there saves 3.0% of spend. Cutting to $200 saves another 3.1 points, about $24,000 a month on a $769,000 bill.
- A hard cap saves exactly what it refuses. Every dollar a hard cap saves is a dollar of work that didn't run that day. At $100, the cap saves 16.2% and turns away 16.2% of the work people asked for, almost all of it from the heaviest 7% of days.
- The other instruction does the heavy lifting. Moving half the tokens one or two tiers down, 40% to Sonnet 5.5 and 10% to Haiku 5.5, saves 29.7% with no cap at all, and halves the share of days that would hit a $100 line.
- Cheaper models make a cap last longer. At an agent token mix, $100 buys about 141 million Opus 5.5 tokens or 201 million at the shifted mix. Same cap, 42% more work.
- If you must cap, degrade before you block. Switching to a cheaper model at $60 and stopping at $100 saves 19.2% while refusing 10.5% of work, against 16.2% and 16.2% for a plain stop.
Below: what Apple's caps buy on each model, two charts, and capcut.py, 76 lines of Python that price any cap and mix policy against your own per-person spend export.
Apple figures are as reported by Bloomberg on November 4, 2026, and relayed by TechCrunch and MacRumors. Apple has not commented, and the reports don't give Apple's model mix or spend data. Everything labeled "our model" is a synthetic month with stated assumptions: lognormal daily spend with a $20 median and a $36.61 mean, and Anthropic list prices from November 2026. No figure here comes from Apple or from Nadir customer data.
What Apple changed.
| Detail | As reported |
|---|---|
| Engineering cap, before October | $300 per person per day |
| Engineering cap, October | $200 for some engineers |
| Next step under discussion | $100 for some allowances |
| Non-engineering teams | Many already at $100 a day, some could go to $25 |
| Exceptions | Employees can ask executives for a bigger budget |
| Tools available | Claude, ChatGPT, Gemini and other models |
| Other instruction | Use less expensive models, or switch to on-device AI |
| How much of the old cap was used | "Few" employees used their full $300, so savings may be small |
| Context | New CEO John Ternus, since September 1, wants a leaner company |
Apple joins a list that now includes Uber's per-tool cap, Walmart's token allocations and the wider tokenminimizing push. What's new is the unit. Most companies cap per month. Apple caps per day, which makes the shape of a single day's spend the thing that decides what the cap does.
What a day's cap buys.
A dollar cap is a token cap with the model left blank. The same $25 or $200 buys very different amounts of work depending on which model the tool calls.
| Daily cap | Fable 5.1 | Opus 5.5 | Sonnet 5.5 | Haiku 5.5 |
|---|---|---|---|---|
| Agent tokens per $25 | 16M | 35M | 70M | 1.1B (222M over 100K context) |
| Agent tokens per $100 | 65M | 141M | 282M | 4.4B |
| Agent tokens per $200 | 130M | 282M | 563M | 8.9B |
| Chat turns per $25 | 454 | 1,136 | 2,272 | 45,454 |
Agent tokens at a mix of 95% cache reads, 3% fresh input and 2% output: $1.538, $0.710, $0.355 and $0.022 per million at list. A chat turn is 3,000 fresh input tokens and 500 output tokens. Haiku 5.5 bills every token at 5x when a prompt passes 100K tokens, which agent sessions often do. Opus 5.5 Fast mode doubles the Opus column's cost.
Two things stand out. A $25 day is very little agent work on a flagship: about 16 million tokens on Fable 5.1, roughly one ordinary day of a coding agent. And it's a lot of chat on anything else. A non-engineer writing emails and summaries on Sonnet 5.5 would need more than 2,000 turns a day to reach $25. So for most of the non-engineering population a $25 cap does nothing, and for the few it touches, it mostly touches whoever picked the expensive model.
On-device AI goes one step further. It has no per-token bill, so moving a request there removes it from the cap entirely. That's a routing decision too: which requests are small enough to run locally.
The cap nobody hits.
AI spend per person per day is skewed. Most days are small: a few questions, a short agent run. A few days are huge: a long refactor, a migration, an agent left running on a big repo. In our synthetic month the median engineer-day costs $20 and the mean is $36.61, pulled up by the long tail.
That shape is why Apple's employees told Bloomberg that few people used their full $300. It's also why a cap saves less than it looks like it should. Days over $100 are 35.8% of spend in our model, but a $100 cap doesn't remove those days. It removes the part of each one above $100, which is 16.2% of spend.
| Hard cap | Days that hit it | Spend saved | Extra saving from the cut |
|---|---|---|---|
| $300 | 0.7% | 3.0% | |
| $200 | 1.8% | 6.1% | +3.1 points, about $24K a month |
| $100 | 7.2% | 16.2% | +10.1 points, about $78K a month |
Going from $300 to $200 touches about one engineer-day in 55. If your distribution looks like this one, it's a signal to the heaviest users more than a cost program.
A cap saves exactly what it refuses.
A hard cap doesn't make any request cheaper. It stops requests. In our model every hard cap lands on the diagonal: the share of spend saved equals the share of requested work that didn't run that day. Some of that work moves to tomorrow, and some gets done by hand. Either way, it's the heaviest users on their heaviest days, often the migration or the incident that justified the tool.
Apple's other instruction moves the point off the diagonal. "Use less expensive models" lowers the price of every request, not the count:
| Policy, our model | $ per month | Saved | Days capped | Work refused |
|---|---|---|---|---|
| No cap, all Opus 5.5 | $768,914 | 0% | 0% | 0% |
| Hard cap $100 | $644,187 | 16.2% | 7.2% | 16.2% |
| Mix shift, no cap | $540,676 | 29.7% | 0% | 0% |
| Mix shift + hard cap $100 | $485,393 | 36.9% | 3.7% | 10.2% |
| Downshift at $60, stop at $100 | $621,185 | 19.2% | 7.2% | 10.5% |
The mix shift here moves 40% of tokens from Opus 5.5 to Sonnet 5.5 and 10% to Haiku 5.5. At an agent mix, Sonnet 5.5 costs exactly half of Opus 5.5 per token and Haiku 5.5 about 3%, so the blended price falls to 0.703x. The saving assumes the cheaper models can actually do the work that moves to them. That's the quality question, and it's the one to measure before you change anything.
The combined row is the one finance should look at. The mix shift lowers every day, so fewer days reach $100: 3.7% instead of 7.2%. The cap then catches only the true outliers, and the refused work drops from 16.2% to 10.2% while savings go up.
If you keep a cap, make it soft.
A hard stop at the cap is the worst way to spend the last part of a budget. The tool works at full price until it doesn't work at all. Three changes make a daily cap cheaper to live with:
- Downshift before you stop. Run the default model up to 60% of the cap, then send the rest of the day to a cheaper tier. In our model that refuses 10.5% of work instead of 16.2% at the same $100 line, and saves more. On a coding agent, many turns are search, read and run-the-tests steps that a smaller model can handle. We looked at routing at that level in Route the Step.
- Cap the default, not the person. Most of a heavy day is the default model running on routine turns. Because most people never touch the model picker, the default model carries most of the bill, as Replit's switch showed in The Default Is the Bill. Changing it moves more money than changing the cap.
- Pace across days, not just within one. A daily cap resets every morning, so it can't save Tuesday's slack for Thursday's migration. A monthly budget with pacing can. We simulated that in Budget Bankruptcy.
Tutorial: capcut.py.
capcut.py prices a month of per-person daily spend under hard caps, a model-mix shift, and a downshift policy, and reports what each saves and how much requested work it refuses. It uses a deterministic synthetic distribution so every run gives the same numbers. To use your own data, replace DAYS with a list of per-person, per-day spend figures from your provider's usage export, in dollars at your current default model.
"""capcut.py: what a daily AI spending cap actually saves, and what it costs.
Daily spend per person is skewed: most days are small, a few are huge. A cap
only touches the days above it, so cutting it saves the tail and blocks the
heaviest work. A cheaper model mix lowers every day. This prices both on a
synthetic month; swap DAYS for your own per-person, per-day spend export.
"""
from math import exp
from statistics import NormalDist
PEOPLE, WORKDAYS = 1000, 21
MEDIAN, SIGMA = 20.0, 1.1 # $ per engineer-day: lognormal median and spread
# Deterministic quantile grid instead of random draws, so every run matches.
N = PEOPLE * WORKDAYS
Z = NormalDist()
DAYS = [MEDIAN * exp(SIGMA * Z.inv_cdf((i + 0.5) / N)) for i in range(N)]
# $ per million tokens at an agent mix: 95% cache read, 3% fresh input, 2% output.
MIX = (0.95, 0.03, 0.02)
RATES = {"Opus 5.5": (0.20, 4.00, 20.00), "Sonnet 5.5": (0.10, 2.00, 10.00),
"Haiku 5.5": (0.01, 0.10, 0.50)}
PRICE = {m: sum(a * b for a, b in zip(MIX, r)) for m, r in RATES.items()}
DEFAULT = "Opus 5.5"
# "Use less expensive models": share of tokens on each tier after the shift.
SHIFT = {"Opus 5.5": 0.50, "Sonnet 5.5": 0.40, "Haiku 5.5": 0.10}
SHIFT_FACTOR = sum(s * PRICE[m] for m, s in SHIFT.items()) / PRICE[DEFAULT]
def hard(x, cap):
"""Spend and share of the day's work done when the tool stops at the cap."""
return min(x, cap), min(1.0, cap / x)
def downshift(x, cap, at=0.6, cheaper="Sonnet 5.5"):
"""Default model until `at` of the cap, then a cheaper one until the cap."""
line = at * cap
if x <= line:
return x, 1.0
ratio = PRICE[cheaper] / PRICE[DEFAULT]
rest = (x - line) * ratio # what the remaining work costs on `cheaper`
if line + rest <= cap:
return line + rest, 1.0
done = line + (cap - line) / ratio # work done, in default-model dollars
return cap, done / x
def run(label, policy=None, cap=None, factor=1.0):
"""Price the month. DAYS are in default-model dollars; factor scales them."""
spend = work = hits = 0.0
for x in DAYS:
s, w = policy(x * factor, cap) if policy else (x * factor, 1.0)
spend += s
work += w * x # work counted in default-model dollars
hits += x * factor > cap if cap else 0
return label, spend, work, hits / N
def report():
base = sum(DAYS)
print(f"{PEOPLE} engineers x {WORKDAYS} days: mean ${base / N:,.2f}/day, "
f"median ${MEDIAN:.2f}, {sum(x > 300 for x in DAYS) / N:.1%} of days over $300")
print(f"agent-mix $/M: " + " ".join(f"{m} ${p:.3f}" for m, p in PRICE.items()))
print(f"mix shift {SHIFT} -> {SHIFT_FACTOR:.3f}x per token\n")
rows = [run("no cap")]
rows += [run(f"hard cap ${c}", hard, c) for c in (300, 200, 100)]
rows += [run("mix shift, no cap", factor=SHIFT_FACTOR),
run("mix shift + hard $100", hard, 100, SHIFT_FACTOR),
run("downshift at 60% of $100", downshift, 100)]
print(f"{'policy':<26}{'$/month':>12}{'saved':>8}{'days capped':>13}{'work refused':>14}")
for label, spend, work, hit in rows:
print(f"{label:<26}{spend:>12,.0f}{1 - spend / base:>8.1%}{hit:>13.1%}{1 - work / base:>14.1%}")
if __name__ == "__main__":
report()
With the defaults it prints:
$ python capcut.py
1000 engineers x 21 days: mean $36.61/day, median $20.00, 0.7% of days over $300
agent-mix $/M: Opus 5.5 $0.710 Sonnet 5.5 $0.355 Haiku 5.5 $0.022
mix shift {'Opus 5.5': 0.5, 'Sonnet 5.5': 0.4, 'Haiku 5.5': 0.1} -> 0.703x per token
policy $/month saved days capped work refused
no cap 768,914 0.0% 0.0% 0.0%
hard cap $300 746,042 3.0% 0.7% 3.0%
hard cap $200 722,126 6.1% 1.8% 6.1%
hard cap $100 644,187 16.2% 7.2% 16.2%
mix shift, no cap 540,676 29.7% 0.0% 0.0%
mix shift + hard $100 485,393 36.9% 3.7% 10.2%
downshift at 60% of $100 621,185 19.2% 7.2% 10.5%
How to read it on your own data:
- Look at "days capped" first. If a cut you're considering touches under 2% of days, it saves little and lands on your heaviest users. Ask what they were doing on those days before you cut.
- Compare the mix shift to the cap. If moving part of the default model's traffic one tier down saves more than the cap, start there. Set
SHIFTto a mix you've tested. - Use "work refused" as the cost of the cap. It's an upper bound on lost output, because some refused work runs the next day. Put a dollar value on an engineer-hour and compare.
What the model leaves out:
- Behavior. People who know about a cap ration earlier in the day. That cuts spend below the cap line too, and nothing here measures whether that work mattered.
- Quality. The mix shift assumes the cheaper tiers do the moved work as well. Test that on your own tasks.
- Per-person patterns. Each day is drawn independently. Real heavy users are heavy most days, so a cap may hit the same few people every week.
When a daily cap is the right tool.
- To stop runaway loops. A high cap, well above any normal day, catches an agent stuck in a loop or a leaked key. That's a safety limit, not a cost program. We covered the attack version in Denial of Wallet.
- When usage is new and unmeasured. A temporary cap buys time to collect the per-day data capcut.py needs.
- When the money really is fixed. If the budget can't move this quarter, a cap enforces it. Pair it with a downshift so the last part of the day still works.
A cap is the wrong tool when the goal is a lower cost per unit of work. It changes how much work happens, not what each piece costs.
Where Nadir fits.
Apple's instruction to "use less expensive models" asks every employee to make a routing decision by hand, request by request. Nadir makes it per request at the gateway.
See your distribution before you set a cap. Nadir's Observe mode serves exactly the model you asked for and records what routing would have picked, so you get per-request cost and the cost under routing on real traffic, with no change to responses. That's the per-day data capcut.py needs, and the mix-shift number measured instead of assumed.
Route the default, not the person. With model=auto, Nadir recommends the lowest-cost model it expects to handle each request and escalates the rest. Your quality floor and model pins stay per API key, so a team that needs the flagship keeps it.
Make caps a backstop. Keep a high cap for loops and leaks, and let routing lower the cost of the ordinary day.
On the hosted gateway 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, run the on-prem audit, or estimate your savings from your current model spend.
Conclusion.
Apple's cap cut is the visible part of the story, and probably the smaller part. If few people used $300 a day, then $200 touches a sliver of days and saves a sliver of spend, and each dollar it saves is work that didn't happen. The instruction underneath it, use cheaper models where they can do the job, lowers the cost of every day instead of stopping the biggest ones. Measure the distribution, shift the mix, and keep the cap high enough that it only catches what you'd want stopped anyway.
Sources: [TechCrunch, "Apple is reportedly cutting budgets for its internal AI usage," November 4, 2026](https://techcrunch.com/2026/11/04/apple-is-reportedly-cutting-budgets-for-its-internal-ai-usage/). [MacRumors, "Apple is Putting Employees on an AI Budget," November 4, 2026](https://www.macrumors.com/2026/11/04/apple-reducing-employee-ai-spending/). [AppleInsider, "Apple employee AI budgets cut to reduce costs," November 4, 2026](https://appleinsider.com/articles/26/11/04/apple-employee-ai-budgets-cut-to-reduce-costs), all reporting Bloomberg. [Anthropic, Pricing](https://platform.claude.com/docs/en/about-claude/pricing), retrieved November 2026. Distribution, mix shift and policy results are our synthetic model, not Apple's or customer data.