Per-employee AI budgets and AI FinOps, explained

Two stories ran side by side in early November 2026. On one side, large employers started rationing AI. Bloomberg reported on 4 November that Apple had cut the daily AI spending limit for some engineers from $300 to $200. A month earlier, 404 Media reported that Accenture now centrally funds only $29 of Claude usage per employee per month. On the other side, vendors cut prices. Anthropic released Claude Fable 5.2 and Mythos 5.2 on 9 November at prices 20% below the previous version. Meta launched Muse Ember, a small model for routine agent work, at $0.10 per million input tokens. Fireworks added a half-price Background Mode for work that can wait.

At first sight this looks like a contradiction. If tokens keep getting cheaper, why are companies capping them? The answer is that the price per token is falling more slowly than the number of tokens is rising. A chat assistant answers a question and stops. A coding agent reads files, runs tests, retries and summarises, often for dozens of steps, and it re-reads its own growing history at every step. Spend per employee grows even as the unit price drops.

This article explains why agent spend grows, how to measure it, which levers cut it, and how to set budgets without punishing your most productive people, with a worked example. The discipline borrows its name from cloud computing: FinOps, making spending visible, owned and optimised. For background on agents, see the agentic AI topic page.

What happened

Apple lowers employee AI spending limits (reported 4 November 2026)

Bloomberg reported on 4 November, citing people familiar with the change, that Apple cut the daily AI spending cap for some engineers from $300 to $200 in October. According to The Next Web's summary of the report, Apple may cut further, taking some engineering teams to $100 a day. Many non-engineering groups already had a $100 daily cap, and Apple has considered lowering that to $25 for some teams. Staff who need more can ask senior leaders for an exemption.

The budgets cover tools including Claude, ChatGPT and Gemini, and some teams are reportedly being told to use cheaper or on-device models. Bloomberg's sources said few people used their full $300, so Macworld noted the savings may be small. Apple declined to comment. The Next Web linked the move to chief executive John Ternus's push to run Apple "faster and leaner". It also listed other reported caps: Tesla at $200 a week per person and Uber at $1,500 a month per AI coding tool.

Accenture funds $29 of Claude per employee per month (reported 15 October 2026)

404 Media reported on 15 October that Accenture told staff in an internal announcement that, from 1 October, it pays $29 per person per month for Claude Enterprise use, and that "all costs are consumption-based". Usage above that amount must be charged to a Work Breakdown Structure code, Accenture's budget code for a specific project or team. Some employees had been spending $500 to $1,000 a month, according to 404 Media. An Accenture spokesperson said the company makes AI available to all its people and that "our approach today is to provide the right tool for the right work."

This is a textbook example of a FinOps pattern called chargeback: a small central allowance, with anything above it billed to the budget that benefits.

Anthropic cuts prices with Claude Fable 5.2 and Mythos 5.2 (9 November 2026)

Anthropic released Claude Fable 5.2 and Mythos 5.2 on Monday 9 November. Reported standard API prices are $8 per million input tokens and $40 per million output tokens, down from $10 and $50 for the 5.1 models, a 20% cut. Dataconomy reported batch prices of $4 and $20, half the standard rate. Fortune reported cached input at $0.20 per million tokens. ITdaily and other outlets reported an optional fast mode at $16 and $80, double the standard price, with up to 2.5 times faster generation. Fable 5.2 is broadly available, while direct access to Mythos 5.2 is limited to vetted organisations in Anthropic's cyber and life sciences programmes.

Meta launches Muse Ember for routine agent work (9 November 2026)

Meta released Muse Ember on 9 November, describing it as its smallest and most efficient model, built for "the work agents repeat all day": tool calls, coding subtasks, routing, extraction and long-document parsing. TechCrunch reported a price of $0.10 per million input tokens; The Decoder reported $0.50 per million output tokens and a context window of up to one million tokens. Meta claims more intelligence per dollar than Anthropic's Haiku and OpenAI's Luna small models. Independent figures cited by The Decoder put Ember at 27.2% on a real-world coding benchmark against 34.9% for Haiku, so "cheaper" and "as capable" are not the same claim.

Fireworks adds half-price Background Mode and multi-day caching (3 November 2026)

At its Forge conference on 3 November, Fireworks announced Background Mode, "a lower-cost runtime option at half price" for work that does not need an immediate answer, such as generating evaluation data or overnight research. It also announced Multi-day Prompt Caching, which lowers the cost of reprocessing context when a persistent agent resumes after a pause. The announcement did not state the cache duration.

Separately, Revolut claimed in October that moving about 2,000 engineers to a self-hosted open-weight model cut its AI coding costs by about 90%. Self-hosting is a larger decision than this article covers.

Why AI spend per employee keeps growing

Agents multiply tokens

Anthropic's engineering team wrote in 2025 that "agents typically use about 4× more tokens than chat interactions, and multi-agent systems use about 15× more tokens than chats." The reason is structural. A chat turn is one request and one answer. An agent loop is many requests: plan, call a tool, read the result, decide, call another tool, and so on. Each request is a full model call.

Think of asking a librarian one question versus hiring a research assistant for an afternoon. Both are useful, but nobody budgets them the same way.

The context is re-read at every step

Most of an agent's bill is input, not output. A model has no memory between calls, so each step resends the system prompt, the tool definitions, the files read so far and the conversation history. If step one sends 10,000 tokens and each step adds 2,000, step thirty sends about 68,000. Total input across the task grows roughly with the square of the number of steps. This is why long coding sessions get expensive quickly, and why context engineering, deciding what goes into each call, is a cost discipline as much as a quality one.

Output is expensive, and so is speed

Output tokens cost five times more than input at Fable 5.2's reported prices, and reasoning models bill hidden "thinking" tokens as output. Fast modes double the price again: worth it for an engineer waiting at the keyboard, pure waste for an overnight job. And cheaper tokens invite more use; without routing and budgets, a price cut can raise total spend.

How to measure AI spend

A monthly vendor invoice tells you almost nothing. Measurement needs three layers.

Layer 1: tokens and dollars, attributed

Log every model call with who made it (user, team, agent), the model, cached and uncached input tokens, output tokens and cost. Group calls by task with a shared trace ID. Agent tracing tools do most of this, and an agent harness is the natural place to attach cost to each step. The cache split matters: a request that is 90% cache hits costs a fraction of one that is 90% misses.

Layer 2: cost per task

Define a few task types, such as "fix a failing test" or "answer a support ticket", and track the median and 95th-percentile cost of each. The median is the normal cost. The 95th percentile catches runaway loops, where most surprise bills come from.

Layer 3: cost per outcome

For coding agents the most useful unit is cost per merged pull request: all AI spend on changes, including abandoned attempts, divided by changes that ship. For support it might be cost per resolved ticket. Outcome metrics protect productive people: an engineer who spends $150 a day and ships ten reviewed changes may be better value than one who spends $20 and ships nothing. A flat cap cannot see that difference.

Metric	What it tells you	Typical use
Tokens per call (cached / uncached / output)	Where the bill comes from technically	Tuning prompts and caching
Cost per task (median, p95)	Normal cost and runaway risk	Setting per-task limits
Cost per merged pull request	Value for money in coding	Comparing tools, models, teams
Spend per person per period	Who is using how much	Budgets, chargeback, showback

The levers that actually cut cost

Model routing

Reading a file or classifying a ticket is routine; planning a refactor is not. LLM routing sends each request to the cheapest model that can do it well. The gap is stark: at reported list prices, Fable 5.2 input costs 80 times more than Muse Ember input. A sub-agent design, where a capable planner hands routine subtasks to small language models, is the natural shape. Before moving a task type, check quality on real examples; evals turn routing from a guess into a decision.

Prompt caching

Because agents resend the same prefix (system prompt, tools, early files) on every step, caching that prefix is usually the single biggest saving. Prompt caching stores the processed prefix so later calls pay a much lower rate for it; at Fable 5.2's reported prices, a cached input token costs one fortieth of an uncached one. Under the hood this reuses the model's KV cache. Caches only match exact prefixes, so put stable content first and changing content last. Fireworks' multi-day caching targets the case where an agent pauses overnight and would otherwise pay full price to rebuild its context in the morning.

Batch and background modes

Work that can wait a few hours is cheaper. Anthropic's batch prices are reported at half the standard rate, and Fireworks' Background Mode is half price. Good candidates are nightly test generation, evaluation runs, documentation refreshes and bulk classification. Think of it as sending a parcel by standard post instead of same-day courier: same parcel, later arrival, lower price.

Context trimming

Summarise old turns, load file sections rather than whole files, drop tool results once used, and cap steps per task. Focused context usually improves quality too.

Budgets per team and per task

Use several levels at once: a per-task limit that stops runaway loops, a per-team monthly budget, and an organisation-wide forecast. See cost and latency budgets for enforcement in code. A task that hits its limit should stop and ask.

Chargeback and showback

Showback shows each team what it spent without billing it. Chargeback bills the team or project, as Accenture now does above $29. Showback alone often cuts waste, because most overspending is invisible rather than deliberate. Chargeback ties spend to value: a project that benefits from heavy agent use pays for it.

A worked example

The figures below are illustrative. All volumes are assumptions, not measurements; the prices are the reported list prices above. Cache-write premiums, hidden reasoning tokens and taxes are ignored for simplicity, so real bills will be somewhat higher.

Assumptions: a coding agent fixes one bug in 30 model calls. Each call sends on average 40,000 input tokens and returns 800 output tokens. That is 1.2 million input tokens and 24,000 output tokens per task. On average 1.5 tasks are attempted for every merged pull request. An engineer runs 10 such tasks a day, 21 working days a month.

Step 1, frontier model, no optimisation. Input: 1.2M × $8 per million = $9.60. Output: 24,000 × $40 per million = $0.96. About $10.56 per task, $15.84 per merged pull request, $105.60 per engineer per day, about $2,218 per month.

Step 2, add prompt caching. Assume 85% of input tokens are cache hits at $0.20 per million. Uncached: 180,000 × $8 per million = $1.44. Cached: 1.02M × $0.20 per million = $0.20. Output unchanged at $0.96. About $2.60 per task, $26 per engineer per day, about $547 per month.

Step 3, add routing. Assume 20 of the 30 calls are routine and go to a small model priced like Muse Ember ($0.10 in, $0.50 out, no caching assumed), while 10 calls stay on the frontier model with caching. Small model: about $0.09. Frontier: about $0.87. About $0.96 per task, $1.43 per merged pull request, $9.56 per engineer per day, about $201 per month.

Under these assumptions, two standard levers cut the cost of the same work by about 90%, the same order of saving Revolut claimed by self-hosting. Moving the remaining frontier calls for non-urgent tasks to a half-price batch mode would cut further.

Now compare with the caps. Unoptimised, this engineer would exceed Apple's reported $100-a-day level and use up Accenture's $29 monthly allowance within its first three tasks. Optimised, the same engineer sits around $10 a day. The lesson is that a cap is only fair once the engineering work on cost has been done. Otherwise it rations waste and productive work equally.

What it means in practice

Flat per-head caps are a blunt first step. Easy to enforce, but they treat a productive heavy user like a wasteful one. Expect a shift towards per-task limits and outcome-based budgets.

Cost becomes a platform responsibility. Engineers cannot set up caching, routing and attribution alone. A platform team, or a gateway every call passes through, has to own it.

Price cuts do not remove the need for controls. A 20% price drop is small next to the fourfold to fifteenfold token multipliers of agents.

Model choice becomes a portfolio: strong models for planning, cheap models for routine steps, batch modes for anything that can wait.

What to do now

Put every model call behind one gateway or proxy so that usage is logged in one place with user, team, task and model attached.
Split token counts into cached, uncached and output in your logs and dashboards, because each has a different price.
Define three to five task types and report median and 95th-percentile cost for each every week.
Track one outcome metric per use case, such as cost per merged pull request or cost per resolved ticket, and review it alongside quality.
Restructure prompts for caching: stable system prompt and tool definitions first, variable content last, then measure the cache hit rate.
Pilot routing on one routine task type, validated with an evaluation set before and after the switch.
Move non-urgent jobs to batch or background modes, starting with evaluation runs and nightly reports.
Set per-task step and spend limits that stop the agent and ask for help, so a loop cannot run all night.
Start with showback before chargeback: show each team its spend and outcome metrics for a month before billing anyone.
Design an exception path for heavy users with clear value, as Apple reportedly has, so caps do not block your most productive people.

Risks and open questions

Most figures here are reported, not confirmed. Apple's limits come from anonymous sources, Accenture's from an internal announcement seen by 404 Media, and Revolut's saving is a conference claim.

Caps can push work into the shadows. When the sanctioned tool runs out, some people turn to personal accounts, creating data-protection risk.

Cheap models are not free if they fail. A small model that gets a task wrong and triggers a retry on the large model can cost more than going to the large model first. Routing without evaluation can raise cost.

Cost per outcome can be gamed. Splitting work into many tiny pull requests improves cost per merged pull request without improving anything. Pair cost metrics with quality and review metrics.

Vendor pricing is complex and changing. Cache durations, long-context surcharges and discounts differ by provider and change often.

Watch next: whether Apple lowers its caps further, whether other large consultancies follow Accenture's chargeback model, independent tests of Muse Ember's quality per dollar, and whether more providers add multi-day caching and discounted background tiers.

Frequently asked questions

Why do companies cap AI spending when prices are falling?

Because usage is rising faster than prices are falling. Agents use several times more tokens than chat and re-read their growing context at every step.

What is AI FinOps?

The practice of making AI spending visible, owned and optimised, borrowed from cloud cost management. It means attributing every call to a person, team and task, measuring cost per outcome, and using routing, caching and batch modes to cut waste.

What is a good unit for measuring coding-agent cost?

Cost per merged pull request. It counts all spend, including failed attempts, divided by changes that ship. Pair it with quality signals such as reverted changes.

Is a flat per-employee cap a bad idea?

It is a reasonable emergency brake but a poor long-term policy, because it cannot tell a productive heavy user from a wasteful one. Per-task limits, outcome metrics and an exception path work better.

Which single change usually saves the most?

For agents that resend long, stable prefixes, prompt caching often saves the most. Routing routine steps to a small model is usually next. Measure your own workload first.

Summary

Apple reportedly cut some engineers' daily AI limits from $300 to $200, and Accenture reportedly funds only $29 of Claude per employee per month, charging overages to projects. Meanwhile Anthropic cut Fable 5.2 and Mythos 5.2 prices by 20%, Meta launched Muse Ember at $0.10 per million input tokens, and Fireworks added half-price Background Mode and multi-day caching. Spend per employee still rises because agents multiply tokens. The fix is engineering before rationing: attribute every call, measure cost per outcome, cache, route, batch, and then set layered budgets with showback, chargeback and an exception path.

Companies cap AI spend per employee while model prices fall: a practical guide to AI FinOps