The Budget Meeting Where the Harness Bill Blew Up
Month four. The CFO has the spend dashboard open before the meeting starts, and the first question is not hostile. Just precise. Models got cheaper this year. Why did our AI line go up? The reconciliation team's PM has thirty seconds to answer with something better than a shrug, because the next budget cycle is in the room, listening.
This episode is that answer, properly built. A harness program is front-loaded. If your CFO hasn't pushed back yet, you haven't built the real budget.
That sentence breaks most AI roadmaps, because they are written by people told AI is cheap. Tokens are cheap. Models are cheap and getting cheaper. The APIs bill per million, the demos bill per pizza night, and everyone in the room has internalized that AI costs look like SaaS costs. Flat, predictable, and mostly about seats.
A real harness program does not look like that. It looks like a database migration from 2012, updated with 2026 vocabulary. There is a large investment in the first four quarters, a flat plateau in the second year, and a compounding return in the third. Assuming the team survives the first two. Most programs die on the plateau, because the CFO asks a reasonable question and the PM has no real answer.
- 01. Why a harness program's real cost shape is front-loaded in Year 1, flat in Year 2, and compounding in Year 3. And why any other shape is a red flag.
- 02. The five cost centers most harness budgets miss, in order of magnitude.
- 03. The runtime cost wedge. Why even open-harness teams pay for the deployment plumbing underneath, and the 30-40% budget undercount most programs make.
- 04. What the reliability dividend is, and how it turns a cost center into a moat.
- 05. The three observable signs that your program has crossed break-even. None of them numerical.
Keep the user outside the cost model. The user is not a line item; the user is what every line item is being spent on. Every cost below lives inside the stack, not in the person requesting the work.
The Real Cost Shape
Year 1 is front-loaded. Year 2 is the plateau. Year 3 is the compounding return. Any other shape is a sign the budget is lying.
Every harness program I've watched survive long enough to matter had the same cost shape. It is not a line. It is three phases, and they look nothing alike.
Year 1 is front-loaded. This is the phase most PMs underestimate by a factor that rounds to everything. In Year 1 you are not paying for AI. You are paying for the infrastructure that lets AI be usable.
Eval frameworks get authored from nothing. Trace storage gets stood up. Ground-truth datasets get hand-labeled by the only people in the org who actually understand what correct means for your workflow. Which is almost never the engineering team.
The best staff engineer in the org loses most of a quarter to harness scaffolding. A senior PM loses most of a quarter to stakeholder translation. If you are telling the CFO that Year 1 will be cheap, you are telling them something false, and you will spend Year 2 paying off that lie.
Year 2 is the plateau. The infrastructure exists. The harness runs. New workflows are cheaper to onboard because the scaffolding is there. Token costs become visible for the first time. Not because they are large, but because everything else has stabilized.
Year 2 is the most politically dangerous phase of the program, because the visible spend has dropped, the returns have not yet compounded, and every executive in the room is primed to ask the reasonable question: “We've built this. What's it done for us?” The honest answer in Year 2 is usually “It has stopped costing us what the unmanaged version was costing us.” That is a true answer.
It is also an answer that ends programs, because loss prevention is invisible in a way that revenue is not.
Year 3 is where the return lives. The harness has absorbed the cost of onboarding new workflows. Evals catch regressions before users do. Autonomy limits can be raised because failures are now recoverable.
The same team that was drowning in Year 1 is now shipping a new agent every quarter at a fraction of the original unit cost. The plateau breaks upward. If you have survived this far, the curve bends in a way that is visible to every stakeholder in the org without you having to defend it.
Most programs never see Year 3. They die on the plateau. Not because the harness was wrong. Because the budget was shaped wrong and the story was told wrong, and the CFO lost patience on month fourteen.
The shape is reliable. The specific magnitudes depend on your org, your domain, and your starting point. A financial services harness with heavy compliance requirements will be front-loaded differently than a customer support harness with looser tolerances. The shape survives. The numbers vary.
Most programs die on the plateau. Not because the harness was wrong. Because the CFO lost patience on month fourteen.
Section OneThe Five Cost Centers Most Budgets Miss
Token spend is almost never the largest cost center. It is usually the fifth. The first four are where the program lives or dies.
Every harness budget I have seen ranks its costs in the same order. Tokens first. Compute second. Everything else buried under Every harness program I have seen run has the opposite ranking.pposite ranking. Token spend is almost never the largest cost center. It is usually the fifth.
Here are the five cost centers that actually matter, in order of magnitude. This ordering has held across every program I've been close enough to count.
One. Eval infrastructure and ground-truth authoring. This is the largest line item, and almost no one budgets for it. An eval suite is not a weekend project. It is a months-long effort to define what correct means for your workflow, to label a representative dataset, to build the harness that runs the evals on every pull request, to tune the thresholds so the signal beats the noise, and to keep the dataset alive as the product evolves.
The first version is expensive. The ongoing maintenance is expensive. The people who can do this work are the same people you need shipping features, which is why most teams under-invest and then pay for it three quarters later when a silent regression reaches production.
If you cut one budget line, do not cut this one. “Evals are the foundation that power the harness hill-climbing process. Evals encode the behavior we want our agent to exhibit in production. They're the ‘training data’ for harness engineering.” (Vivek Trivedy, LangChain, Better Harness: Hill-Climbing with Evals, April 2026).
The cost center is the training data for everything else your harness does.
Two. Staff engineer and PM attention during ramp. A harness program takes your best engineer and your best PM off the ship-rate for most of Year 1. This is real money. The staff engineer who could have shipped three major features is instead architecting the control plane, the observation plane, and the escalation patterns.
The PM who could have been running discovery is instead translating between engineering, safety, legal, and the exec team. Neither of these people is cheap. Both are invisible on the token-spend line. If you do not name this cost up front, it shows up later as roadmap slippage, and the CFO discovers it in a form nobody budgeted for.
Three. Observability stack and trace storage. You cannot run a harness without seeing what it does. Every agent invocation generates traces. Structured records of prompts, tool calls, intermediate reasoning, tokens consumed, latencies observed, errors caught.
At scale, these traces are large. Storage costs compound. Query infrastructure for debugging at production volume is not free. The observability vendors know this and price accordingly. Most budgets treat this as infrastructure overhead and underestimate it by a factor of several.
By the time you realize you needed 90-day retention instead of 14-day, the bill has a shape nobody planned for.
Four. Human review for high-stakes paths. A mature harness routes a fraction of cases to humans. Refunds above a threshold. Medical decisions outside the confidence band. Legal language the agent won't generate unsupervised.
Compliance outputs that need sign-off. The humans doing this review are not junior. They cannot be outsourced to the cheapest labor market, because the whole point is that their judgment is what the harness is preserving.
This cost is structural, and it does not go away as the model improves. It just moves up the stack to harder cases.
And the queue itself is infrastructure, not just headcount. Run the arithmetic once and it stops being abstract: route 3% of sessions to review at 10,000 daily sessions and you have 300 reviews a day. At five minutes each, 25 person-hours, every day.
Triple the volume and you are staffing a full-time function. The line item has three parts most budgets skip: review tooling (interfaces that surface the right trace context to the reviewer), escalation routing (the right case to the right reviewer at the right time), and calibration dashboards (catching reviewers whose judgments have drifted from the rubric. A reviewer who has not recalibrated in sixty days is scoring against personal taste, and neither of you knows it). The queue is a system. Budget for it like one.
Five. Harness-versioning discipline. This is the line item never budgeted but always costly. Every harness version. Every eval threshold change, every tool schema migration, every prompt template deprecation. Has to be managed like any other production API contract.
Teams that underinvest here end up with three years of accreted scaffolding, half of it rotting, nobody brave enough to delete it, and every model upgrade becoming a week-long migration. The cost of not doing this discipline is not visible in Year 1. It shows up in Year 3 as the program's inability to keep up with the frontier.
The discipline itself is cheap. The absence of it is ruinous.
Token spend, compute, API bills. Those are real costs. They are not the shape-defining costs for most programs. One honest caveat: at extreme fleet scale, tokens can climb the ranking, and this exception is instructive.
The lesson is that cost controls are a permanent harness responsibility, because the agent's default behavior is to spend more. More retries, more context, more parallel attempts. No model release fixes that.
The budget cap lives in the harness, forever. Episode 8. When the Harness Becomes the Habit files this under permanent residents, where it belongs.
The 2026 Token Ledger. Prices Collapse, Bills Triple
Per-token prices fell by two thirds in a year. Enterprise bills tripled anyway. The gap between those two facts is the whole story. And it is a harness decision.
And bills still tripled. Average enterprise AI budgets grew from roughly $1.2 million in 2024 to $7 mThe reconciliation: reasoning and agentic workloads consume five to thirty times the tokens of an equivalent chat interaction.hat interaction. A linear workflow that cost about $0.04 per interaction in 2023 costs roughly $1.20 as an orchestrated agentic system in 2026 (thirty times more), even as the price of each token fell.
This is why FinOps X 2026 (June 10) pivoted the whole conference past token economics. Unit price is not the story. Consumption is the story. And consumption is a harness decision.
Remember Datadog's finding from Episode 2: 69% of input tokens in production traces are system prompts. That is system-prompt overhead being paid on every turn, and it is a memory-policy choice, not a vendor price.
The harness has three consumption levers. Model routing: Frontier for reasoning, Sonnet or Haiku for triage, a semantic cache for repeated patterns. Effort control: Opus 4.8 offers a manual effort dial per workflow, so you stop paying reasoning prices for lookup work. Consumption attribution: spend tracked per cluster, per workflow, per failure. So you know which part of the harness is expensive, not just that the bill is.
The frontier now hands you the discounts directly. Opus 4.8's fast mode is 3x cheaper than 4.7's was, and the prompt-cache minimum dropped to 1,024 tokens. But you only capture these benefits through a harness that routes and caches deliberately. Routing is also a continuity plan: Fable 5's nineteen-day suspension is the reminder that the model you route to today may be gone tomorrow.
And the mOn June 15, Anthropic announced it was separating programmatic agent usage. GitHub Actions. GitHub Actions. From subscription pools into per-user monthly credits ($20 Pro / $100 Max 5x / $200 Max 20x). It paused the change before it took effect, but the end-state is public: interactive use subsidized, autonomous programmatic use metered. Budget as if the meter turns on.
Token prices fell 67%. Bills tripled. The gap between those two facts is agentic consumption. And the harness is the only control surface consumption has.
Section Two-BThe Lock-In Wedge. Open vs. Closed Harness Economics
Two programs with identical Year 1 costs can diverge by a factor of three by Year 3. The difference is architectural, not operational. Most CFOs never see it on a finance review.
Two programs can have identical Year 1 costs and diverge by a factor of three by Year 3. The difference is not how many tokens they burn or how many engineers they staff. It is whether their harness is open or closed. That single architectural choice creates a cost wedge that compounds every quarter; most CFOs never see it on a finance review.
“Every workflow should be open” is as wrong as “every workflow should be closed.”
For roughly 60% of enterprise use cases, a closed stack is correct. Internal productivity, non-differentiating CX, commodity agent workflows where the harness is not where your advantage lives. The other 40%. Agents that are the product, regulated workflows, anything that depends on proprietary evals as moat. Should budget for the Year 1 cost of an open harness because the alternative is a Year 3 migration nobody wants to underwrite.
A third contract shape entered the market in April 2026 and deserves its own line in the analysis: the managed meta-harness. Anthropic's Managed Agents rents you the hardest infrastructure. Durable sessions, sandboxes, the agent loop. Through stable interfaces, your evals, policies, and workflows remain in your hands (Episode 2 covers the architecture).
For the forty percent, this reshapes the Year 1 front-load: you no longer build the plumbing to own the judgment. The wedge analysis still applies. You are trusting a vendor's interfaces. But interfaces designed to outlive their own implementations are a fundamentally better lock-in profile than a closed harness that owns your memory policy outright.
The CFO question is not “should we build or buy.” It is “for this workflow, what does the three-year cost shape look like under each path, including the cost of being wrong?” If you can answer that for each workflow in your portfolio, you are one of the few programs doing the math honestly.
The lock-in wedge is the Year 3 cost for Year 1 convenience. It never shows up on a purchase order.
Section ThreeThe Runtime Cost Wedge
The lock-in wedge is one cost story. The runtime is a second one most enterprises miss until Year 2.
The lock-in wedge is one cost story. The runtime cost is a second one most enterprises miss until Year 2.
Even with an open harness, you pay for the runtime that runs it: durable execution, checkpoints, multi-tenancy, audit-grade observability, time travel for debugging. These are not small line items. The vendors selling runtime, LangSmith Deployment, AWS Bedrock AgentCore, Google Vertex Agent Engine, price for the operational complexity, not the model tokens. A team that built its own harness from scratch but bought the runtime is in a hybrid posture that is, for many enterprises, the right answer.
The choice question is not “do we own the runtime.” Most teams should not. The question is: do we know we bought a runtime, and do we have an exit story if the vendor changes pricing or sunsets the product.
If the answer to either is no, you are taking on a Year 3 surprise the open-harness logic from Episode 4 already named.
A useful rule of thumb: a harness budget that does not include a runtime line is undercounting cost by something like 30 to 40 percent. The infrastructure-grade pieces, observability backend, durable storage, audit pipeline, are real costs whether you build or buy.
What Harnesses Actually Return, Beyond Productivity
Productivity gains are the surface argument. The reliability dividend is the one that survives a CFO push-back.
Every AI ROI deck I've read leads with productivity. Engineers ship faster. Analysts query faster. Support resolves faster. These are real gains. They are also not the argument that will save your program when the CFO pushes back.
The argument that saves your program is the reliability dividend, and it is the most under-communicated part of harness ROI.
Here is the mechanism. A harness does not directly make your agent smarter. It makes your agent's failures recoverable and auditable, and that shift, from “the agent fails unrecoverably” to “the agent fails into a workflow that catches and corrects”, is what changes how much autonomy you can grant it.
Think about what an autonomy limit actually is. An agent handles 5% of tickets. Why 5%? Because 5% is what the organization will tolerate as a loss if the agent goes wrong. Push it to 10% and the expected value of a bad decision starts to exceed the value of the automation.
Push it to 30% and every legal, safety, and customer-success stakeholder is in the room blocking the launch.
A harness does not change the model's judgment. It changes what happens when the judgment is wrong. With a real harness, a wrong decision at 3 AM gets caught by an eval gate, routed to a human, reversed within a defined window, and logged into a trace that the regulator can audit. With no harness, a wrong decision at 3 AM is found by a customer complaint on Twitter three weeks later.
Same model. Same error rate. Radically different organizational exposure.
The cleanest demonstration of this arithmetic arrived in May 2026, in a controlled comparison on an Opus-class model. Same model, same prompt, run twice. No harness: $9 of spend, 20 minutes of runtime, output that could not be used.
Full harness, persistent state, verification gates, scoped instructions, a session lifecycle, $200, six hours, a playable game. (Practitioner-reported; trust the shape of the result more than the decimals.) Look at what the extra $191 bought.
Not intelligence. The weights never changed. It bought output the organization can actNo-harness version is 95% cheaper and worth exactly zero, according to practitioners.th exactly zero. The harness version costs 22x more and is worth whatever a working product is worth. The reliability dividend is the difference between cheap and worthless. That is the sentence to take into the budget review.
This is why the autonomy limit moves. Not because the model got better. Because the consequences of being wrong got smaller. A team with a real harness can raise its autonomy from 5% to 30% without the organization flinching, because the cost of a bad decision has been engineered down to something manageable.
A team without a harness can have the best model in the world and still be stuck at 5%, because the organization has correctly intuited that the downside is unbounded.
The reliability dividend is this: once the harness is solid, the same AI investment produces multiples more output, because the organization finally trusts the system enough to let it operate at the scale the technology was always capable of.
Productivity gains compound from 5x more volume, not 5x faster completion. This is the gain that does not show up in a demo and does not show up in a token bill. It shows up in the number of workflows that migrate from “human does everything” to “agent handles most, human handles edges”, which is to say, it shows up on the P&L in a way that is unmistakable, once you know to look.
The Dividend, With Names Attached
The dividend is no longer a projection. It has named, audited-by-the-press case studies, and you should carry both into your next budget review because they come from different domains and tell the same story.
Rakuten deployed Claude Code — a harness, as Episode 2 established — across its engineering teams and cut average feature delivery from 24 working days to 5. Engineers now run several tasks in parallel by delegating most of them to the agent.
One autonomous session ran for seven hours across a 12.5-million-line codebase and held 99.9% accuracy on a complex implementation. Note what changed and what did not: Rakuten had access to the same Claude models before. The gain arrived when the harness made multi-hour autonomous work safe to run.
Microsoft's Azure SRE Agent tells the same story from infrastructure operations. Over a thousand agent instances run across Azure, mitigating tens of thousands of incidents autonomously. And time-to-mitigation for one major service class dropped from 40.5 hours to 3 minutes.
The architecture is a textbook of this series: narrow tool boundaries through MCP, human approval required for destructive actions, autonomy adjustable across three named rungs of the same harness. These are not Year 3 compounding stories.
Both are Year 1 and Year 2 results. The front-load is real; so is the dividend.
Token spend is one line item. It is not the return. The July 2026 evidence, Harness-Bench reports across score, completion, security, tool use, consistency, robustness, tokens, and turns, makes the case that reliable production teams optimize the cost per reliable completed workflow, not the cost per token. LangChain's survey confirms it: quality has overtaken cost as the top production blocker (State of Agent Engineering).
- Completion quality. Validated end-to-end task completion, not model answer quality.
- Recovery. Retry success rate, resumability after sandbox failure, partial-work preservation.
- Safety. Blocked risky actions, permission violations avoided, escalation precision.
- Efficiency. Tokens, turns, tool calls, elapsed time, sandbox utilization.
- Operability. Trace completeness, incident triage time, evaluator coverage.
Microsoft's MDASH makes the point in extremis: their security harness intentionally orchestrates 100+ specialized agents and an ensemble of models because the return the team is buying is exploitable-risk discovery, not minimum inference cost. Advanced harnesses use more models on purpose. That is not waste; it is what the return line demands.
The harness does not change the model's judgment. It changes what happens when the judgment is wrong. That is the entire dividend.
Section FourThe Break-Even Quarter. And The Three Signs
Break-even is legible in behavior before it is legible in numbers. The dashboard lags. Watch the CFO instead.
Every CFO wants the break-even quarter. Every honest PM says the same thing: the quarter is different by org, by domain, by starting point, and by how aggressively you are willing to measure.
The shape, though, is reliable. Break-even for a serious harness program usually lands somewhere in the second year, after the front-loaded cost has absorbed and before the Year 3 compounding kicks in.
Aggressive programs with narrow workflows can cross earlier. Programs with heavy regulatory overhead cross later. If a vendor tells you they can get you to break-even inside two quarters, they are either selling a scaffolding-only solution that will dissolve into the next model release or they are showing you a demo-grade number that does not survive contact with production.
The more useful question is not which quarter. It is how will I know when I've crossed it?
And this is where most PMs look for the wrong signal. They look for a revenue line, a productivity number, a percentage. Break-even is rarely legible in those terms in the quarter it actually happens. By the time the numbers are unambiguous, you are a quarter past it.
The three signs are observational. None of them are numerical. All of them are, once you know to look, unmistakable.
Sign one. Engineers stop rewriting prompts every sprint. In Year 1, every sprint has at least one prompt rewrite, usually more. The scaffolding is young. The failure modes are new. The prompts drift.
Somewhere in Year 2, if the harness is working, this stops. Not because the prompts got perfect. Because the eval suite caught the failure modes, the verification layer absorbed the drift, and the tool scopes narrowed the surface enough that prompt churn became a Year 1 artifact.
When engineering stops treating prompts as the primary lever, you are approaching break-even.
Sign two. The eval suite catches regressions before users do. This is the single cleanest signal of a working harness. In Year 1, regressions are discovered by users, then triaged, then reproduced, then fixed, then eventually added to the eval suite as a regression test.
In a mature harness, that loop runs backwards. The eval suite catches the regression on the pull request. The user never sees it. The customer-success team stops logging incidents for categories the harness now defends.
When this reversal happens, your cost of a regression has dropped by one to two orders of magnitude, and the organization has started to trust the system in a way it could not before.
Sign three. The CFO stops asking for the business case and starts asking for the expansion plan. This is the one PMs miss, because it does not feel like a finance conversation, but it is. Early in a harness program, every budget review is a re-litigation: What did we spend? What did it return? Should we keep going?
Once the program crosses break-even, the conversation changes. The CFO stops asking whether to continue and starts asking what else the harness could cover: Can we run the compliance workflow on it? Can the support harness be extended to onboarding? What would it take to add two more teams? The question shifts from defense to expansion, and that shift is the clearest business-case signal you will ever get, usually a quarter or two before the ROI numbers catch up.
None of these signs are numerical. All of them are, in practice, more reliable than the numbers. Numbers lag. Organizational behavior leads. A PM who watches for these three signals will know they have crossed break-even about a quarter before the dashboard does.
Break-even is legible in behavior before it is legible in numbers. Watch the CFO. The CFO will tell you.
Section FiveCompliance-by-Design Is Cheaper Than the Retrofit
Regulated verticals, healthcare, finance, defense, aerospace, have to design the harness with compliance baked in from day one. Retrofitting compliance into a running harness is ruinously expensive. The cost center nobody budgets for in Year 1 shows up as an 8-12 month timeline slip in Year 2, when the audit trail layer needs to be rebuilt because the original control plane did not carry the right primitives.
The broader pattern is visible in several healthcare agent rollouts I have observed. Initial implementations ship fast without audit-grade provenance, regulators flag gaps, and the control plane gets rebuilt in place while the program runs. The design that would have passed a SOC 2 audit on day one usually existed in the spec. It did not survive contact with a ship-fast culture that saw audit as a Year 2 problem.
The design principle. Every Interception-cluster hook has two implementations running in lockstep: the functional one and the audit one. This roughly doubles harness complexity in Year 1. It is non-negotiable for HIPAA, SOX, GLBA, MiFID II, DO-178C, ITAR, and FAA-certified workflows. The budget ask looks expensive until you compare it with the rebuild cost, at which point it looks like the cheap option.
Next Actions: Controlling the Bill
The worst conversation to have with a CFO is the one where you cannot answer basic questions about the shape of your own investment. The best defense against that conversation is to answer the questions in your head today, before you are asked.
Before the next sprint ends, a PM running a harness program should be able to answer five questions without looking anything up.
If you cannot answer these cleanly, that is the work for this week.
Not philosophy. Not strategy. The actual work. What do you do first?
You now have the cost shape, the cost centers, the token ledger, the reliability dividend, and the break-even signals. You can walk into a finance review with an answer for every objection, without inventing a single number. What you do not have yet is the tactical kit. The specific work for the next seven days: the audit that tells you where your harness actually stands, the sprint-planning ticket, and the script for walking engineering, design, and the exec team through the investment, three different translations of one defensible plan. You have the business case. What do you actually do on Monday? The next episode is that kit.
Sources
Anthropic NIST RFI Response (March 2026). Four-layer framing; cost centers map to the control, observation, and escalation layers.
Anthropic: Effective Harnesses for Long-Running Agents (November 2025). Reliability dividend framing.
Opus harness/no-harness controlled comparison (May 2026). Practitioner-reported; $9/20min/unusable vs $200/6hrs/playable.
Rakuten: Accelerating Development with Claude Code: 24 days → 5 days time-to-market; 7-hour autonomous session on a 12.5M-line codebase.
Microsoft: How We Build and Use Azure SRE Agent (April 2026): 40.5 hours → 3 minutes time-to-mitigation; adjustable autonomy on one harness.
Anthropic: Scaling Managed Agents (April 2026). The managed meta-harness as a third procurement shape.
Sydney Runkle, LangChain. Open-harness visibility and model-agnostic economics (June 2026). Visibility as a first-class lock-in cost.
Jerry Liu, LlamaIndex. Model-mix optimization (June 2026): 2–10x cost/latency wins inside sophisticated harnesses.
Reported fleet-scale cost example (May 2026): ~100 Codex instances, 603B tokens, 7.6M requests, >$1.3M in 30 days; reported, single source.
Linux Foundation. A2A protocol surpasses 150 organizations (April 2026). Protocol portability as lock-in axis.
MCP security analysis, arXiv 2601.17549 (January 2026): 23–41% injection amplification without controls.
MCP design patterns survey, arXiv 2603.13417 (March 2026): 10,000+ active MCP servers.
OpenAI Codex Best Practices (February 2026). Production cost shape vs. demo-grade cost shape.
Vivek Trivedy, LangChain: Better Harness. Hill-Climbing with Evals (April 2026). Eval infrastructure as foundational cost.
Practitioner interviews across enterprise AI programs, 2025-2026. Cost-center ordering abstracted throughout.
FinOps Foundation: Token Economics. The Atomic Unit of AI Value (2026): $18.40 → $6.07/M tokens (−67% YoY, 2.4B enterprise calls); 5–30x agentic multiplier; budget growth $1.2M → $7M.
SiliconANGLE: FinOps X 2026. Agentic costs emerge beyond token economics (June 10, 2026).
Anthropic support: Use the Claude Agent SDK with your Claude plan (updated June 15, 2026). Announced-then-paused metering of programmatic agent usage; credit tiers.
OpenAI API changelog (June 3, 2026). Agent Builder and Evals retirement, effective November 30, 2026.
Anthropic: Claude Opus 4.8 (May 28, 2026). Fast mode 3x cheaper; 1,024-token cache minimum and mid-task system updates.
Key Takeaways
- Expect a lot up front, a flat middle, and a slow win later. These programs cost a lot in year one, feel stuck in year two, and pay off in year three. Teams that budget for a straight line quit right before the return arrives.
- The bill you see is not the cost that matters. The model invoice is visible. The costs that actually decide whether this works. Evals, people's time, monitoring, human review, keeping versions tidy. Are mostly invisible and mostly bigger. Budget the ones you can't see.
- Cheaper models don't mean cheaper systems. Each call gets cheaper, but agents make many more calls, retry more, and branch more. Total spend keeps going up. Control it inside your system. Smarter routing, less overthinking, knowing which part cost what. Long before you renegotiate with a vendor.
- Don't rent the parts that encode your judgment. Vendors don't just raise prices; sometimes they shut products down. Anything holding your test data, your failure taxonomy, or your definition of quality must be easy to move, the day it isn't, someone else owns your roadmap.
- The real payoff is that being wrong gets cheap. A good harness doesn't mostly save tokens; it makes mistakes less scary. Once failures are cheap and recoverable, you can hand the agent work you'd never have trusted it with before. That expansion is where the real money is.
- You'll feel it work before you see it in the numbers. Prompt tinkering slows down. Your evals catch bugs before users do. Finance stops asking "is this worth it?" and starts asking "where else can we use it?" The spreadsheet catches up a quarter later.
- Decide open vs. closed on purpose, workflow by workflow. Every workflow ends up either transparent (you can inspect what happened) or opaque (a vendor handles it). Choose deliberately, with audit and compliance cost included, because the ones you don't classify get classified for you, and never in your favor.
How this episode connects to the rest of the stack
Each link points to the same problem, told from a different seat.
- Agentic · T29. Agent EconomicsSame math, written for the architecture seat.
- Agentic · T17. Context EconomicsWhere the token line item actually lives.
- Agentic · T25. The Autonomy DesignHow reliability earns the right to raise autonomy.
- Evals · T26. Eval EconomicsThe eval cost line, rarely budgeted, always paid.