The $100 Day

TL;DR.

On November 4, Bloomberg reported that Apple cut some engineers' daily AI allowance from $300 to $200 in October, and plans to take some engineering teams as low as $100 a day. Many non-engineering teams are already at $100, and Apple has considered $25 for some of them. The caps cover tokens on outside models, including Anthropic's Claude. Some teams are being pushed to cheaper models or to models that run on the device.

Apple isn't alone. Uber caps each employee at $1,500 a month per AI coding tool. Tesla set $200 a week. Accenture centrally funds $29 a month of Claude per employee. The per-person AI allowance is now a line in the engineering handbook.

So what does a $100 day actually buy, and how do you fit a heavy coding-agent day inside it? We priced one illustrative day of 480 agent turns at Anthropic list prices:

• With Fable 5.2 on everything, the day costs $137.10. That fits under the old $200 cap. Under a $100 cap, the engineer is locked out at 2:58 PM.
• Output tokens are 56% of that bill. On Fable 5.2, re-reading cached context costs only $0.20 per million tokens, so it's 15%. The context habits that matter most on cheaper models matter less here.
• Four changes take the same day to $32.31: no cold restarts, /clear between tasks, the model picked per task, and shorter answers on routine work. Picking the model is the big one, worth $61.90 on its own.
• The cheaper day still uses Fable 5.2 for the three hardest tasks. Moving everyone to Sonnet 5.5 would cost about the same and lose that.

Below: the caps side by side, three charts, the four changes in order, and daypace.py, 40 lines that price your own day against your own cap.

Apple figures are as reported by Bloomberg via 9to5Mac and MacRumors on November 4, 2026; Uber via Bloomberg and PYMNTS; Tesla via The Information; Accenture via Forbes. Prices are Anthropic list prices as of November 14, 2026. The engineer's day, its session shapes, model mix and output sizes are illustrative assumptions, not Apple data and not Nadir customer data.

The new allowance, side by side.

Caps come in different units: per day, per week, per month, per tool. Converted to a workday (5 days a week, 22 a month), they line up like this:

Two things from the reporting are worth holding onto.

Few people were using the old cap. Bloomberg's sources said few Apple workers used their full $300. A cap like that only binds the heaviest users, and in coding agents the heaviest users are a small group spending most of the money. We showed how lopsided that distribution is in The 680x Gap. Lowering the cap from $300 to $100 doesn't trim everyone a bit. It changes the day of the few people at the top.

The advice came with the cap. Apple told some teams to use cheaper models or on-device ones. That's the right instinct, applied with a blunt tool. "Use a cheaper model" for a whole team is a default change. Below, we'll see why a choice per task does better.

What a $100 day buys.

Here's the day we priced. One engineer, one coding agent, eight hours, about one agent turn a minute: 480 turns. The agent starts every session with a 25,000-token prefix (system prompt, tool definitions, project rules) and adds 2,500 tokens of context per turn: file reads, command output, its own answers. It writes 4,000 output tokens a turn, thinking included.

In the baseline, the engineer works the way a lot of us do: Fable 5.2 as the default model, three long sessions a day of 160 turns each, never cleared, and four breaks per session longer than the five-minute cache. Each break means the next turn re-writes the whole context at the cache-write rate.

That day costs $137.10:

Under Apple's October cap of $200, that's fine. Under $100, here's when the day ends:

2:58 PM. Two hours of work left and no budget. The engineer either asks a senior leader for an exception, waits until tomorrow, or switches to a cheaper model mid-task, which re-writes the whole context on a new model's cache and is often the worst of the three. A daily cap doesn't know which of the day's tasks were worth the money. It just stops at whichever one happens to be running.

The share table also says something specific about Fable 5.2. Its cache reads are $0.20 per million, 0.025x its input price, the same as Opus 5.5's. So a long session that re-reads 200K tokens a turn is cheap per turn on Fable, and the bill is mostly output at $40 per million. On models where cache reads cost 0.1x input, context hygiene is usually the first lever. On Fable, the model and the output length come first. We worked through that rate card in Fable 5.2: The 20% Is the Small Number.

Four changes, in order.

Measure before any of them: the last section shows how.

1. Don't let the cache go cold mid-session

Each cold restart in the baseline re-writes an average of about 230K tokens at $10 per million instead of reading them at $0.20. Twelve of them cost $27.75, a fifth of the day. Finish a task before the meeting, or /clear before you leave and start fresh after, rather than resuming a 300K session that has to be re-written from scratch. One cold restart at 300K tokens on Fable 5.2 costs $2.94 more than a warm turn. If your breaks are predictable, the one-hour cache write ($16 per million on Fable 5.2) can be cheaper than re-writing twice.

2. Clear between tasks

The baseline runs 160 turns per session, so by the end every turn re-reads more than 400K tokens. Splitting the day into 12 tasks of 40 turns, with /clear between them, keeps the context under 125K. On Fable that saves only $12.42, because Fable's cache reads are already cheap. It matters more for the next step: a task that starts with a clean context is the natural place to choose a model, and it keeps cheap models under their own price cliffs.

3. Pick the model per task

This is the change that fits the day under the cap. Of the 12 tasks, we assumed three need Fable 5.2 (a cross-module refactor, a concurrency bug, a design review), five are ordinary feature and test work for Sonnet 5.5, and four are mechanical (renames, lint fixes, a changelog, a dependency bump) for Haiku 5.5:

Three things make this work.

Choose at the start of a task, not between turns. Each model keeps its own prompt cache. Switching models in the middle of a 100K-token session re-writes 100K tokens on the new model before it does anything useful. We priced that trade in the switch penalty.

Keep Haiku tasks short. Haiku 5.5 charges five times more per token once a prompt passes 100K. In this day, a 40-turn Haiku task crosses that line at turn 31. Clear before it does, or the last ten turns cost more than the first thirty. The details are in the Haiku 5.5 100K cliff.

Don't solve it by downgrading everyone. Moving the whole team's default to Sonnet 5.5 with the same habits as the baseline costs $39.51 for this day. That's under the cap too, but it runs the three hard tasks on a model you didn't pick for them, and it costs more than the routed day that keeps Fable on them. Apple's "use cheaper models" advice is right per task and wrong as a team default.

4. Shorter answers on routine work

Cutting output on the Sonnet and Haiku tasks from 4,000 to 2,000 tokens a turn (lower reasoning effort, no restating the diff, terse summaries) saves $4.31. It's small here because those tasks are already cheap. On the Fable tasks, where output is $40 per million, effort is the bigger lever: the same 2,000-token cut on the three Fable tasks would save $9.60, more than twice as much, if those tasks still come out right at lower effort. Do the routing first and then look at effort where the money still is.

Price your own day.

daypace.py prices a day of agent work, task by task, against a daily cap. Replace TASKS with your own: the model, the number of turns, output tokens per turn and cold restarts.

"""daypace.py: price one coding-agent day against a daily cap.
Anthropic list prices, $ per million tokens, November 14, 2026."""
CAP = 100.0
BASE, GROW = 25_000, 2_500      # prefix at turn 0, context added per turn
RATES = {  # input, 5-min cache write, cache read, output
    "fable":  (8.00, 10.00, 0.20, 40.00),
    "sonnet": (2.00, 2.50, 0.10, 10.00),
    "haiku":  (0.10, 0.125, 0.01, 0.50),
    "haiku_long": (0.50, 0.625, 0.05, 2.50),   # Haiku 5.5 prompt over 100K
}

def rate(model, ctx):
    return RATES["haiku_long"] if model == "haiku" and ctx > 100_000 else RATES[model]

def task(model, turns, out_per_turn, cold_restarts=0):
    """Yield the cost of each turn. A cold restart re-writes the whole prefix."""
    ctx = BASE
    cold = {round((i + 1) * turns / (cold_restarts + 1)) for i in range(cold_restarts)}
    for t in range(turns):
        _, write, read, out = rate(model, ctx)
        cost = ctx * write if t == 0 or t in cold else ctx * read + GROW * write
        yield (cost + out_per_turn * out) / 1e6
        ctx += GROW

TASKS = [("fable", 40, 4000)] * 3 + [("sonnet", 40, 2000)] * 5 + [("haiku", 30, 2000)] * 4

spent, turn = 0.0, 0
for spec in TASKS:
    for cost in task(*spec):
        spent, turn = spent + cost, turn + 1
        if spent > CAP:
            print(f"cap hit at turn {turn}, {9 + turn // 60}:{turn % 60:02d} at one turn a minute")
            raise SystemExit
print(f"day: ${spent:.2f} over {turn} turns, ${CAP - spent:.2f} left")

With the mix above it prints day: $31.87 over 440 turns, $68.13 left. Set TASKS to [("fable", 160, 4000, 4)] * 3 and it prints cap hit at turn 358, 14:58 at one turn a minute.

Your real numbers are in your logs. `npx nadir-receipt` reads your local Claude Code and Codex history, prices it at API list prices and splits it into re-reading context, adding context and answers. It runs locally and makes no network calls. --budget takes a monthly figure and shows the day it runs out at your current pace, so npx nadir-receipt --days 7 --budget 2200 checks the last week against a $100 workday cap. Details are on the receipt page.

If you set the cap.

A daily cap is a cheap control to ship and a crude one to live with. Three things make it work better:

• Cap the default model, not just the dollars. The allowance in this post survived a 4x tighter cap once the model was chosen per task. A cap plus a sensible default fixes more than a cap alone. We made the longer case in the $500M bill and Tokenminimizing.
• Pace the budget, don't wall it. A cap that cuts off at 2:58 PM stops whatever task is running. Stepping down a tier as the day's spend crosses 70% or 80% degrades gracefully instead. Budget Bankruptcy has the pacing math.
• Make the exception path cheap. Apple and Uber both let people ask for more. If asking takes a day, the cap costs an afternoon of engineering every time it trips. Uber burned its annual budget in four months before it set per-tool caps; the companies that keep caps tend to be the ones with a fast way around them.

Where Nadir fits.

The biggest change in this post is the third one: choosing the cheapest model that can handle each task, and keeping your configured model as the ceiling for the work that needs it. Doing that by hand means stopping to decide before every task, and most people stop deciding by the second day.

Nadir Auto makes that choice in Claude Code and Codex. Before each turn it asks for a model, keeps the model you configured as the quality fallback and cost ceiling, and checks what a switch would cost in cache re-writes before it moves you. It writes a local receipt for every turn, so you can see what it chose and why. It works without a Nadir key on the anonymous decision quota, and inference stays on your own provider account.

For the person who set the cap, Nadir Lens shows AI coding-agent spend by team and member, cache economics, and agent loops, with a gateway-enforced model allowlist. That's the data you need to tell a $100 day that's being wasted from one that's being used well.

We don't publish a savings rate. Run the receipt on your own history and see what your day looks like first.

If you run AI spend for a team that just got a cap, start with How to Reduce Claude Code Costs and the calculator.