AI Cost Governance: Budgeting Tokens, Seats and Agents
UIB University 365 Institute of Business
Series Business AI Series
Duration 25 minutes
Business Management, Digital Entrepreneurship, Innovation, Finance, Leadership
UNOP Sound (University 365 Neuroscience Oriented Pedagogy)
Take five minutes to prepare your brain. Play the isochronous tone track (40Hz gamma frequency) with your eyes closed. Gamma-frequency tones before a learning session raise attention and make the material easier to absorb.
[Audio player: UNOP Pre-Lecture Isochrone (40Hz, 5 minutes)]
In this Lecture
AI Cost Governance: Budgeting Tokens, Seats and Agents
The Invoice That Arrived on the First Monday of November
The bill was nine thousand four hundred dollars. In January the same line had been four hundred. Nobody had changed the plan, nobody had hired, and the work had not changed much either. What changed was the shape of the spend: a subscription had become a metered API key, and that key had been copied into four projects, one of which ran an agent that called a model in a loop until the task looked finished.
The team could tell you what each person's subscription cost. It could not tell you which workflow produced the other nine thousand dollars, which model did most of the work, or which of the four keys had grown. The invoice arrived once a month, thirty days after the money was spent, and by then the person who had made the decision had moved to another project.
This lecture exists to stop that. It treats AI spend as three lines with three meters, three control surfaces and three failure modes: the seat, the token pool and the agent budget. Organisations that treat them as one line get the invoice above. Organisations that separate them can run the same work for less than half the money, and can say who spent it.
One date note. Every price here was verified on 14 November 2026, with the November 2026 Model Recruitment lecture as the house baseline. That baseline carries one scheduled change: Gemini 4 Carbon and Argon are $2 input and $10 output per million tokens through 30 November 2026, then $4 and $20 from 1 December. Read every number as a dated fact.
AI Cost Governance: Budgeting Tokens, Seats and Agents
Three Meters: Seat, Token Pool, Agent Budget
Most cost confusion comes from using one phrase, "AI spend", for three different products.
A seat is a monthly subscription for one person. You pay a fixed fee and receive access to a set of models under message and time limits. The meter is a person, the price is fixed, and the quota is not a number of tokens you can audit.
A token pool is metered API access, billed per million input tokens, per million cached input tokens and per million output tokens. The meter is a key, the price is linear in usage, and the control is a spend limit.
An agent budget is the cost of a workflow that decides how many model calls to make. One user request can become four calls or forty. The meter is a run, the cost is multiplicative in steps and context, and the only control that works sits in the code that runs the loop.
Line | Meter | Price shape | Where the cap lives | Failure if ungoverned |
Seat | person | fixed monthly | seat inventory and renewal date | paying for access nobody uses |
Token pool | key | linear per token | provider spend limit and gateway budget | silent growth on one project |
Agent budget | run | multiplicative per step | step, tool and token limits in code | one loop consumes the quarter |
The distinction has a practical consequence. Seat thinking applied to a token pool produces the sentence "we already pay for ChatGPT, so this is covered". It is not covered: a subscription buys a person access to a chat product, not permission for a system to call a model. Token thinking applied to an agent produces a forecast multiplied by an average number of steps that the agent chooses at run time, which is not a forecast.
If you want the theory of per-token cost, latency and the economics of a single agent decision, the UIT lecture Inference Economics: Tokens, Latency and the Cost of an Agent covers it. This lecture stays on the operating side: the budget, the cap, the owner and the alert.
The Seat: A Fixed Line With a Hidden Quota
The seat is the easiest line to buy and the easiest to waste.
Prices read on 14 November 2026: ChatGPT Plus is $20 a month and ChatGPT Pro starts at $100. Claude Pro is $20 a month ($17 on annual billing), Claude Max is $100 and Claude Ultra is $200. Google AI Pro is $19.99 and Google AI Ultra is $99.99 or $199.99. None of the three vendors publishes a token allowance for these plans: the limits are messages, usage windows and multipliers, not a convertible quantity of tokens.
Plan | Price per month | What the price buys | Published token allowance |
ChatGPT Plus | $20 | GPT-6 Luna, GPT-6 Sol, GPT-6 Astra, expanded limits | None; message limits |
ChatGPT Pro | from $100 | all models expanded, Astra reasoning, three usage tiers | None; usage tiers |
Claude Pro | $20 ($17 annual) | Haiku, Sonnet, Opus, Fable with usage credits | None; 5-hour and weekly limits |
Claude Max | $100 | 5x Pro usage, Fable up to half the weekly limit | None; 5-hour and weekly limits |
Claude Ultra | $200 | 10x Pro weekly usage, no 5-hour limit, Fable | None; weekly limit |
Google AI Pro | $19.99 | 4x Free usage, Gemini 4 Argon | None; usage multiplier |
Google AI Ultra | $99.99 or $199.99 | 5x or 20x Pro usage, Gemini 4 Carbon | None; usage multiplier |
Prices exclude tax and were verified on 14 November 2026.
That last fact decides how you govern a seat: you cannot budget it by token, so you budget it by person and govern it as inventory.
Forty analysts on ChatGPT Pro at $100 is $4,000 a month. If twelve accounts have not been used in thirty days, the idle line is $1,200 a month, or $14,400 a year, for access nobody opened. That is the size of the prize, and it is found by reading an activity report, not by negotiating.
Four controls make a seat estate governable. One named holder per seat: a shared login is not a discount, it is an audit hole and a data-terms problem. A recorded purpose and tier: most holders of a $200 seat use the top model for a small share of their work, and a $20 seat plus an API key is frequently cheaper. A renewal date you can see: one quarterly list of seats, holders, last active date and renewal date pays for itself. A reclamation rule agreed in advance: access unused for a defined window returns to the pool, and the person is told the rule when the seat is issued.
AI Cost Governance: Budgeting Tokens, Seats and Agents
The Token Pool: Pricing the Metered Line
The token pool is where the money actually moves, and it is the line with the widest price range on the market. Prices are per million tokens, verified on 14 November 2026. The one-task column uses 20,000 input tokens and 2,000 output tokens: a realistic brief with a context file and three examples attached.
Model | Input $ per 1M | Cache read $ per 1M | Output $ per 1M | Cost of one task |
GPT-6 Luna | 0.10 | 0.01 | 0.50 | $0.003 |
Claude Haiku 5.5 | 0.10 | 0.01 | 0.50 | $0.003 |
GPT-6.1 Terra | 1.00 | 0.05 | 5.00 | $0.03 |
Gemini 4 Hydrogen | 1.50 | 0.075 | 7.50 | $0.045 |
GPT-6.1 Sol | 2.00 | 0.10 | 10.00 | $0.06 |
Claude Sonnet 5.5 | 2.00 | 0.10 | 10.00 | $0.06 |
Claude Opus 5.5 | 4.00 | 0.20 | 20.00 | $0.12 |
Claude Fable 5.2 | 8.00 | 0.20 | 40.00 | $0.24 |
GPT-6 Astra | 10.00 | 1.00 | 50.00 | $0.30 |
The same task costs one hundred times more at the top of that table than at the bottom. That range is the largest lever you have, and it is a routing decision rather than a negotiation. A rule that says "the default model for a drafting task is Terra, and Sol requires a named reason" is worth more than a discount of ten percent.
A token pool has four controls, and they live in three different places.
Control | Where it lives | What it stops |
hard spend limit per key | vendor console | a runaway month |
daily budget per key | gateway or proxy | a runaway day |
model allowlist per key | gateway | an accidental request to the most expensive model |
maximum output tokens per request | application code | verbose output at output prices |
The vendor's spend limit is the backstop, not the plan. It stops the disaster, but it fires late and tells you nothing about which workflow crossed the line. The gateway budget is the useful control: it sits in front of every call, it can attribute the call to a key, a team and a workflow, and it can refuse a request instead of warning you after the fact.
AI Cost Governance: Budgeting Tokens, Seats and Agents
The Agent Budget: The Volatile Line
An agent is a workflow that chooses its own number of model calls. That single property turns a linear price into a multiplicative one.
Here is a realistic run on GPT-6.1 Sol: a purchase-order triage agent that takes a document, checks it against a policy, looks up a supplier record, drafts an exception note and decides whether to escalate. In the measured shape, that is twelve model calls. The first call carries a 4,000 token instruction. Each later call carries the growing history: about 14,000 input tokens per step, of which 10,000 sit in a stable prefix that can be read from cache. Each call returns about 400 tokens.
Component | Tokens per run | Price per 1M | Cost |
fresh input, 12 steps at 4,000 | 48,000 | $2.00 | $0.096 |
cached input, 12 steps at 10,000 | 120,000 | $0.10 | $0.012 |
output, 12 steps at 400 | 4,800 | $10.00 | $0.048 |
total | $0.156 |
Without the cache, the same run costs $0.384: 168,000 input tokens at $2.00 is $0.336, plus $0.048 of output. Caching cuts 59 percent of the bill on this workload before any other change. At 8,000 runs a month, the cached run is $1,248 and the uncached run is $3,072.
Now the property that makes this line volatile. You did not decide that the run would take twelve steps. The agent decided, at run time, based on what it found. An ambiguous policy document may make it look again, a failed tool call may make it retry, a search returning forty documents may make it read all forty. Each of those decisions multiplies the line above, and none of them appears in a forecast built from average token counts.
That is why an agent budget is not a finance line. It is a set of limits in the code path that runs the loop. If the limit is not in the loop, it does not exist: a spend limit at the vendor will eventually stop the bleeding, but it will stop it after the run has already cost thirty times the median, and it will stop the wrong workflow.
Four limits matter: maximum steps, maximum tool calls, maximum total tokens and maximum cost per run. Each one is a line of configuration with a value that comes from a measurement rather than a guess. Measure twenty real runs, take the 95th percentile of steps, and set the ceiling slightly above it. A cap set at the average will break normal work; a cap set at nothing will break the budget.
AI Cost Governance: Budgeting Tokens, Seats and Agents
What One Agent Run Actually Costs When It Goes Wrong
The arithmetic above is the good case. The instructive part is the shape of the bad cases, because each one has a different cause and a different fix.
One step of the same agent costs $0.013: $0.008 for 4,000 fresh input tokens, $0.001 for 10,000 cache reads and $0.004 for 400 output tokens. That number is the unit of damage. Every failure below is a count of extra steps.
Failure | Extra steps | Cost per affected run | Monthly cost at the stated volume |
a loop that repeats a step 20 times instead of once | 19 | +$0.247, run becomes $0.403 | $494 on 2,000 runs |
a retry storm, 3 retries at each of 12 steps | 36 | +$0.468, run becomes $0.624 | $234 on 500 runs |
tool fan-out, 40 documents read in one call instead of 8 | 6 heavy calls | +$0.960, run becomes $1.116 | $960 on 1,000 runs |
context creep, history untrimmed, 6,000 extra tokens per step | 0 | +$1.020, run becomes $1.176 | $510 on 500 runs |
The loop is the classic: an agent that repeats a step until the task "looks finished", with no maximum step count, will occasionally run twenty steps on a task that needed one. The retry storm is the expensive cousin: a timing-out tool retried three times at every step multiplies a run by four, and it lands on the morning the vendor's search endpoint is degraded.
Tool fan-out is the failure people miss because it looks like good behaviour: the agent receives forty documents and reads all of them in one call, 100,000 input tokens and $0.20 at Sol prices, across six steps. Capping documents per step at eight turns that into $0.04 per step and $0.264 per run. Context creep is the slow one: untrimmed history takes twelve steps from 168,000 to 564,000 input tokens and the run from $0.156 to $1.176, and a rolling window with a summarisation step at 20,000 tokens is the fix.
None of these four is a model problem. All four are configuration, and all four are invisible on the invoice until you reconstruct the runs, which is why you log steps, tokens and cost per run from day one.
AI Cost Governance: Budgeting Tokens, Seats and Agents
Caching: The Cheapest Cap Nobody Turns On
A cache read is the same tokens at a fraction of the input price: between 5 and 10 percent of the input rate on the models above. GPT-6.1 Sol reads at $0.10 against $2.00, GPT-6 Luna at $0.01 against $0.10.
The saving is large because most workflows repeat themselves. A support assistant sends the same system prompt, tools and retrieved policy passages on every call. A drafting assistant resends the same brand guide and three examples. Those are the tokens that should never be paid twice.
Take the assistant on GPT-6.1 Terra, 20,000 input tokens and 2,000 output tokens per task. Uncached, one task costs $0.020 of input and $0.010 of output, so $0.030. With 14,000 of the 20,000 input tokens read from cache and 6,000 fresh, the input is $0.006 plus $0.0007, and the task costs $0.0167. That is 44 percent off, and at 6,000 tasks a month it is $100.20 instead of $180.
The catch is the write. OpenAI charges no cache write fee. Anthropic charges a 5-minute cache write at 1.25 times the input rate and a 1-hour write at 2 times the input rate. Google uses implicit caching and also charges a storage fee per hour. Those terms change the break-even.
Write premium | Break-even | Rule |
none (OpenAI) | first reuse | cache every stable prefix |
1.25x, 5-minute TTL (Anthropic) | second call | cache prefixes reused within five minutes |
2x, 1-hour TTL (Anthropic) | third call | cache only prefixes reused several times an hour |
Arithmetic for the second row: writing a prefix costs 1.25 times its normal price, then each read costs 0.1 times. Two calls with the cache cost 1.35 against 2.0 uncached, so the cache wins from the second call. In the third row the write costs 2 times, so three calls cost 2.2 against 3.0; the cache wins from the third call.
Whether you get the saving depends on the order of the prompt. The cache matches a prefix, from the start of the request. System prompt first, tools second, retrieved documents third, the user's question last. Put the date, the user's name or the question at the top and you have changed the prefix on every call, which turns a 44 percent saving into a write fee paid on every request.
Monitor the cache hit rate as a number, with a target above 60 percent on repeat workflows, and treat a sudden drop as a cost incident. Make the prompt order a reviewed convention in the code: a developer who moves a timestamp to the top of the system prompt can double a bill without changing a single output.
AI Cost Governance: Budgeting Tokens, Seats and Agents
The Cap Ladder: Soft, Hard and Kill
A cap is only a cap if it does something without a meeting. If crossing the threshold requires a conversation before anything changes, you have an alert, not a cap. Use four levels, and give each one an action that is automatic.
Level | Trigger | Automatic action | Owner notified |
Observe | 50 percent of monthly budget | none; log the projection | budget owner |
Soft | 75 percent | route to the cheaper model tier, reduce agent concurrency | budget owner and workflow owner |
Hard | 100 percent | refuse new runs, queue requests, keep existing work running | both owners, finance partner |
Kill | per-run ceiling or daily ceiling breached | stop the workflow, disable the key, page the owner | all three, plus platform owner |
The soft level is the one that earns its keep. Routing a drafting task from GPT-6.1 Sol at $0.06 to Terra at $0.03 halves the per-task rate, and at 75 percent of budget one routing rule is often the difference between finishing at 100 percent and finishing at 130 percent. Downgrading a model is reversible, visible in the output, and buys ten days.
The hard level needs a queue, not an error. A design that throws errors at users at the end of the month teaches them to find a personal key. Queuing, batching and a clear message ("this workflow reached its monthly budget, the request will run tomorrow") keep the control inside the system.
The kill level is reserved for the single run or the single day. A per-run ceiling of $0.50 against a median run of $0.156 stops the loop that would otherwise cost $4 on one task. A daily ceiling stops the retry storm on the morning the search endpoint degrades. Both are cheap code-level checks, and both decide whether you read about an incident in a log or in a board pack.
Level | Implementation | Why there |
provider spend limit | vendor console, per key | last line of defence; cannot be bypassed by application code |
gateway budget and model allowlist | proxy in front of every call | attributes cost, refuses requests, routes models |
step, tool and token limits | application code in the loop | the only place that knows what a run is doing |
concurrency and daily ceiling | scheduler | stops many runs from failing at once |
AI Cost Governance: Budgeting Tokens, Seats and Agents
Owners: One Name on Every Line
A budget without a name is a wish. The test for an owner is not seniority, it is authority: can this person turn the line off, or change the model, without asking anyone? If not, they are a commentator.
Four roles cover the three meters, and they are deliberately different people.
Line | Owner | Can decide alone | Escalates when |
seat estate | business unit lead | add, reclaim or change a tier | a seat is needed for a regulated role |
token pool | platform owner | rotate keys, set daily budgets, change the allowlist | a team asks for a limit above the pool |
agent budget | workflow owner | set step, tool and token ceilings; pause the workflow | the business needs the workflow through a cap breach |
allocation and forecast | finance partner | set the allocation key and the review date | a chargeback is disputed |
The workflow owner is the role most often missing, and the agent budget is the line that suffers. A platform team can own the gateway, the keys and the spend limits, but it cannot know that a triage agent should stop at twelve steps rather than thirty. That knowledge sits with the person who owns the process being automated, and that person has to be named in writing.
Write the name in the system of record, next to the key and next to the workflow, not in a slide three months old. Then make the name appear in the alert. "Budget threshold reached" goes to a shared inbox and dies; "the purchase-order triage agent reached 75 percent of its monthly budget, workflow owner Denise, action: routing to Terra" gets a decision.
One more discipline: the owner of a line reads the line without asking an analyst. Month to date, projection, top three workflows and cap status, in a view they can open. Access to that view is part of the ownership, not a favour from the data team.
AI Cost Governance: Budgeting Tokens, Seats and Agents
Alerts That Fire Before the Invoice
The monthly invoice is a post-mortem. By the time it arrives, the money is spent and the decision that caused it is thirty days old. Six alerts move the same information thirty days earlier, and six is deliberate: an alert set that fires every day is an alert set nobody reads.
Alert | Condition | What it tells you |
budget threshold | 50, 75, 90 and 100 percent of the monthly budget | how much room is left |
projection | month-to-date divided by days elapsed, times days in month | where the month will end |
burn rate change | today above three times the trailing seven-day median | something started that did not exist last week |
per-run ceiling | any single run above the ceiling | a loop, a fan-out or a retry storm |
cache hit rate | below 60 percent on a repeat workflow | a prompt order change, or a new caller |
price change | a vendor announcement or a contract date | a step change you can plan for |
The projection alert is the one that buys time. With a team budget of $1,920 and $700 spent by day 8, the projection is 700 divided by 8, times 30, which is $2,625: 37 percent over budget with 22 days left, visible on the eighth of the month rather than the first of the next.
The per-run alert is the one that catches agents. A monthly budget cannot see a single expensive run until many of them have happened; a per-run ceiling fires on the first one. Set it from the measured 95th percentile, alert above it, and block above a hard multiple of it.
The cache alert is the one people forget. A drop in hit rate from 70 to 20 percent doubles the input line with no change in output, and it usually comes from a prompt edit made for a good reason. Treat it as a regression, with the seriousness of a broken test.
Then route every alert to a person and an action, not to a channel. The channel is where alerts go to be ignored.
AI Cost Governance: Budgeting Tokens, Seats and Agents
A Worked Monthly Budget for One Team
Here is the model, filled in for a real shape: a business team of eight people, one shared assistant for drafting and summarising, and one production agent for purchase-order triage. All prices are the 14 November 2026 rates from the tables above.
Line | Quantity | Unit cost | Monthly | Owner | Cap | Alert at |
ChatGPT Plus seats | 6 | $20 | $120.00 | business unit lead | 8 seats | 7 seats used |
ChatGPT Pro seats | 2 | $100 | $200.00 | business unit lead | 2 seats | any seat idle 30 days |
assistant token pool, Terra with cache | 6,000 tasks | $0.0167 | $100.20 | platform owner | $150 per month | $112.50 |
agent runs, Sol with cache | 8,000 runs | $0.156 | $1,248.00 | workflow owner | $1,500 per month | $1,125.00 |
contingency | $250.23 | finance partner | held, not allocated | drawn above 90 percent | ||
total | $1,918.43 | $2,110 hard | $959 and $1,439 |
Four things make this model usable rather than decorative. The lines are separated by meter, so each has the control that fits it. The caps sum to more than the budget on purpose: the hard cap sits 10 percent above plan, because a cap set exactly at plan interrupts service the first time a month runs hot. The contingency is held by finance, not allocated to a team. Every line has a name.
Now the part that pays for the work. Run the same estate without the controls and compare.
Lever | Monthly effect | Basis |
right-size seats from 8 Pro to 6 Plus and 2 Pro | -$480.00 | $800 becomes $320 |
turn on caching for the assistant | -$79.80 | $180.00 becomes $100.20 |
cap tool fan-out at 8 documents per step | -$960.00 | 1,000 affected runs at $0.96 |
add a step limit of 12 to the agent | -$494.00 | 2,000 runs that would have looped |
cap retries at 2 per tool call | -$234.00 | 500 runs in a degraded morning |
trim context at 20,000 tokens | -$510.00 | 500 runs with creep |
total avoided | -$2,757.80 | $33,093.60 a year |
That total is larger than the governed budget. The money you are trying to save is not hidden in a discount; it sits in defaults nobody set: an uncapped step count, an uncached prefix, a fan-out with no limit, a seat estate nobody counts.
AI Cost Governance: Budgeting Tokens, Seats and Agents
Procurement: The Clauses That Protect the Budget
Most cost governance happens after the contract is signed, which is late. Six clauses protect more money than a quarter of tuning.
Price change notice. A defined notice period before a list price changes. The November 2026 example is concrete: Gemini 4 Carbon and Argon are $2 input and $10 output per million tokens through 30 November 2026, then $4 and $20 from 1 December. A December budget built on November prices doubles that line. Notice does not prevent the change; it prevents the surprise.
Model deprecation notice. A date and a migration window before a model is withdrawn: a workflow pinned to a withdrawn model is an outage with a bill attached.
Committed use with a floor, not a ceiling. Commit a share of forecast, not the forecast. If the annual agent line is $14,976, committing 70 percent is $10,483; at an illustrative 15 percent discount on the committed portion, that is $1,572 a year saved, and the uncommitted 30 percent absorbs a change in volume.
Overage terms and spend limits. A per-key hard limit in the vendor console, available without a support ticket, is a governance feature. Ask for it in writing.
Cache pricing, published. If caching is part of your model, the rate and the write premium need to be contractual facts.
Invoice detail at key level. An invoice with one total is not auditable; line detail by key or project is the minimum for showback.
Two behaviours matter more than the clauses. Do not sign a multi-year commitment on a workload measured for less than ninety days. And re-read the price page on the first working day of each quarter: a number verified in one month is a fact about that month.
AI Cost Governance: Budgeting Tokens, Seats and Agents
The Monthly Cost Review: Five Numbers, Fifteen Minutes
The cadence is one meeting a month, fifteen minutes, one page, five numbers.
Number | Question it answers | Bad sign |
total spend against budget | are we inside the plan | above 100 percent with no approved exception |
cost per completed unit | is the work getting cheaper or dearer | rising two months in a row |
cache hit rate | are we paying twice for the same tokens | below 60 percent on a repeat workflow |
top three cost drivers | where the money actually goes | a driver nobody can name an owner for |
cap breaches | are the limits working | more than two per month, or any silent breach |
The review is not a reporting exercise. Its output is a decision, recorded: a routing change, a seat reclaimed, a ceiling adjusted, a workflow paused, a contract clause invoked. A review that produces no decision three months out of four is a report, and reports do not govern spend.
Two rules keep it short. The owner presents their own line, never an analyst. And the only acceptable answer to "why did this rise" is a specific cause with a date, because "more usage" is what the invoice already said.
Allocation closes the loop. Direct the cost to the team that causes it wherever you can: seats to the named holder, token pools by key tag, agent runs by workflow. Allocate a shared service only when you must, by transaction count rather than equally, and run showback for a quarter before any charge moves. A team that cannot influence a line should not be charged for it.
That is the whole operating model: three meters, a cap ladder, a named owner per line, six alerts, one monthly review. It fits on a page, which is the point. Governance that needs a programme office to explain it will not survive its second quarter.
AI Cost Governance: Budgeting Tokens, Seats and Agents
Six Ways Cost Governance Fails
The failure modes are predictable, and each one has a cheap countermeasure.
Failure | How it looks | Countermeasure |
the personal key | a developer's own key pays for production work until an expense report appears | an approved key path that takes minutes |
the seat that covers nothing | a team believes its subscriptions cover the workflow, then meets a metered invoice | state the boundary and tag every key to a budget |
the cap that fires at 100 percent | the vendor spend limit is the only limit, so the first signal is a refusal on the last day | the ladder, with the soft level working at 75 percent |
the chargeback nobody agreed to | finance allocates a shared cost with a key nobody saw, and the meeting becomes a dispute | showback first, key published, challenges before money moves |
the agent with no step limit | it works on clean test inputs and loops in production | ceilings on steps, tools, tokens and cost from the 95th percentile |
the budget with no owner | everyone agrees it matters, nobody can change it | one name per line, with the authority to turn it off |
There is a seventh, and it is the most expensive: treating cost governance as a finance project. The levers are technical (caching, routing, step limits, context trimming) and the accountability is managerial (owners, review, allocation). A finance team alone can measure the problem; a platform team alone can fix the mechanics. The organisations that get AI cost under control put the two in the same monthly meeting with the same five numbers.
AI Cost Governance: Budgeting Tokens, Seats and Agents
Feynman Summary: Explain It Like You Are 12
Imagine you run a lemonade stand, and you buy three different things.
The first is a monthly pass to a machine that squeezes lemons. You pay once, you use it as much as the pass allows, and if you do not show up, you still paid. That is a seat.
The second is buying lemon juice by the bottle. Every bottle has a price, and the more you pour, the more you pay. That is a token pool.
The third is hiring a helper who decides how many bottles to open. You say "make lemonade for this order", and the helper might open one bottle or twenty, depending on how the order looks. That is an agent.
Now the problem at the start of this lecture. The stand owner looked at the pass, assumed it covered everything, and got a bill for twenty bottles. Nobody had written down how many bottles the helper could open, nobody had checked whether it was opening bottles it did not need, and nobody had noticed that some bottles were the same juice poured again.
Fixing it does not need a finance degree. Write down who has a pass and cancel the ones nobody uses. Put a lid on the shelf so the helper cannot open more than eight. Tell the helper to stop after twelve steps. Reuse the juice you already squeezed when the order matches the last one. Then look at the numbers every month and ask the person in charge of each shelf why the number moved.
That is cost governance. The hard part is not the arithmetic. It is remembering that you have three shelves, not one.
AI Cost Governance: Budgeting Tokens, Seats and Agents
Mindmap: The Complete Picture
The mindmap shows the whole model on one page: the three meters, the control that fits each one, the four failures that a missing control allows, the cap ladder, the named owners, the six alerts and the monthly review that closes the loop.
UNOP Sound (University 365 Neuroscience Oriented Pedagogy)
Take five minutes to consolidate your memory. Play the isochronous tone track (10Hz alpha frequency) with your eyes closed. Alpha-frequency tones after a learning session support consolidation, helping move what you just learned from short-term to long-term memory.
[Audio player: UNOP Post-Lecture Isochrone (10Hz, 5 minutes)]
AI Cost Governance: Budgeting Tokens, Seats and Agents
Practical Exercise: Build the Cost Model for One Team
Choose one team and one workflow that calls a model. Build the model in a spreadsheet with one row per meter and keep it: this page turns cost governance from an opinion into a control.
Count the seats. List every holder, plan, monthly price, renewal date and last active date. Compute the idle line: seats unused for thirty days multiplied by their price.
Tag the keys. One key per team or workflow, tag recorded next to the budget. A key you cannot attribute is a finding in itself.
Measure one task. Take ten real assistant tasks and record input, cached input and output tokens. Price them at the 14 November 2026 rates, then re-price with the cache switched on.
Measure one agent run. Log steps, tool calls, context size per step and cost. Take the 95th percentile of steps and set the ceiling just above it.
Set the ladder. Write the four thresholds (50, 75, 100 percent of budget, plus the per-run ceiling), the automatic action at each, and the name notified.
Write the projection formula. Month-to-date divided by days elapsed, times days in the month. Run it on the eighth, fifteenth and twenty-second.
Book the review. Fifteen minutes, same day each month, one page, five numbers, one decision recorded.
Then do one thing this week: turn on caching for the workflow with the most repeated prefix, and note the change in the model. A cost model that produces one saving in its first week survives; a perfect model in a document does not.
AI Cost Governance: Budgeting Tokens, Seats and Agents
Glossary
Term | Definition |
Seat | A monthly subscription giving one person access to a set of models under message and time limits, with no published token allowance |
Token pool | Metered API access billed per million input, cached input and output tokens, controlled by a spend limit on a key |
Agent budget | The cost of a workflow that chooses its own number of model calls, controlled by step, tool, token and cost ceilings in code |
Cache read | A repeated input prefix billed at a lower rate than fresh input, typically 5 to 10 percent of the input price |
Cache write | The premium charged once to store a prefix for reuse, 1.25 times input for a 5-minute cache and 2 times for 1 hour |
Unbounded loop | An agent that repeats a step until the task looks finished, with no maximum step count, multiplying the run cost |
Retry storm | A failing tool call retried at every step, which multiplies a run by three or four on a degraded morning |
Tool fan-out | An agent reading far more documents than the task needs in a single call, which inflates input tokens per step |
Context creep | Untrimmed history that makes input tokens grow at every step, so a twelve-step run costs several times its baseline |
Hard cap | A limit that refuses or queues work automatically when a threshold is crossed, with no approval step in between |
Showback | Reporting cost to each team without moving money, used to agree an allocation key before chargeback begins |
Committed use | A contract committing a share of forecast spend in exchange for a discount, sized below the forecast floor so unused capacity stays small |
AI Cost Governance: Budgeting Tokens, Seats and Agents
Quiz: TEST YOUR UNDERSTANDING
1. Which statement about a ChatGPT or Claude subscription is accurate?
A) It covers API usage for workflows the team builds
B) It publishes a token allowance you can convert into a budget
C) It covers a person at the keyboard, not programmatic calls
D) It removes the need for a spend limit
2. An agent run uses 12 steps with 4,000 fresh input tokens, 10,000 cached input tokens and 400 output tokens per step on GPT-6.1 Sol. What does one run cost?
A) $0.0156
B) $0.156
C) $0.384
D) $1.56
3. Which limit stops a tool fan-out from inflating the bill?
A) A monthly spend limit at the vendor
B) A maximum number of documents read per step
C) A higher cache write premium
D) A larger context window
4. What makes a cap real rather than decorative?
A) It is written in the governance policy
B) It triggers an automatic action with a named owner notified
C) It is reviewed annually by finance
D) It sits exactly at the monthly budget
5. Gemini 4 Carbon and Argon are $2 input and $10 output per million tokens through 30 November 2026. What happens on 1 December 2026?
A) The price falls to $1 and $5
B) The price stays the same
C) The price rises to $4 input and $20 output
D) The models are withdrawn
Answers: 1-C, 2-B, 3-B, 4-B, 5-C
Related Resources
U365 INSIDE Publications
External Resources
Related U365 Lectures (Coming Soon)
Inference Economics: Tokens, Latency and the Cost of an Agent (UIT, Technical AI Series)
AI Vendor and Model Due Diligence (Business AI Series)
Task Redesign with AI: Rebuilding Roles Around Agents (Business AI Series)
AI Cost Governance: Budgeting Tokens, Seats and Agents
U.Copilot for This Lecture
You are my AI cost governance analyst. I am responsible for one team's AI spend and I need a budget with caps, owners and alerts. Team: [size, roles, business unit] Workflows that call a model: [list each one, with volumes per month] Current monthly spend and the lines you can see on the invoice: [figures] Contract situation: [subscriptions, API keys, committed use, renewal dates] Do six things: 1. Separate my spend into seats, token pools and agent budgets, and tell me which line is growing fastest and why. 2. Price one representative task and one representative agent run with the 14 November 2026 rates, showing the arithmetic. 3. Identify the three limits most likely to be missing from my agent workflows, and the cost each one is exposing me to at my stated volume. 4. Propose the cap ladder with four thresholds, the automatic action at each, and the name who is notified. 5. Name the owner for each line and the decision each owner can take alone. 6. Draft the one-page monthly review with the five numbers, and the projection formula I should run on the eighth of the month. Ask me for the token counts per run if I have not given them, and do not estimate a price without stating its date.
AI Cost Governance: Budgeting Tokens, Seats and Agents
Next Steps
Count every seat this week: holder, plan, monthly price, renewal date and last active date. Compute the idle line.
Tag every API key to a team or workflow, and record the tag beside the budget in the same system.
Measure twenty real agent runs and set the step, tool and token ceilings at the 95th percentile of what you measured.
Turn on caching for the workflow with the most repeated prefix, then confirm the cache hit rate is above 60 percent.
Put the six alerts in place, routed to named people with an action, and book the fifteen-minute monthly review.
AI Cost Governance: Budgeting Tokens, Seats and Agents
IMPORTANT NOTICE
Copyright University 365, Inc. All rights reserved. This lecture is provided for educational purposes and does not constitute legal, financial or professional advice. For enrollment, visit university-365.com/tuition. For permissions or inquiries, contact uda@university-365.com.
Published by the Department of Academics, University 365.
Lecture delivered by the University 365 Institute of Business (UIB).
Denise Cromwell, Dean of Business, UIB
Signed for the academic year 2026.
Comments