The most instructive AI story of the year has a strange shape: the tools worked, the engineers used them exactly as designed — and the annual budget was still gone by spring.
That is what happened at Uber. The company rolled out Claude Code to roughly 5,000 engineers; within three months, 84% of developers were classified as agentic coding users, and within four, the entire annual AI budget was exhausted, with CTO Praveen ppalli Naga admitting he was “back to the drawing board” (The Information; Forbes). Average spend ran $150–250 per engineer per month, heavy users hit $2,000, and Naga himself burned $1,200 in a single two-hour demo session. Microsoft has reportedly been canceling most of its direct Claude Code licenses over similar cost dynamics (Fortune, citing The Verge), and Uber’s CTO now talks openly about the end of what he calls the “tokenmaxxing era”.
That combination is the subject of this article. The industry has started calling AI agents a “digital workforce,” and the metaphor is more accurate than most people using it realize — because a workforce has an economics. It has a cost structure, a productivity curve, supervision overhead, and a price for mistakes. What broke at Uber, and what is currently breaking in finance departments across the industry, is a simpler and older thing: a mental model. Companies bought agents the way they buy software. Agents behave like labor.
For teams building financial products, where agent errors carry regulatory weight and budgets answer to CFOs, understanding this economics has become a prerequisite for shipping agents at all. Gartner expects spending on AI agent software to reach nearly $207 billion in 2026 — up more than 139% from $86.4 billion in 2025 (Gartner forecast, as reported by Fortune). Very few of the organizations behind that number can currently tell you what one completed agent task costs them.
Why agents break the SaaS mental model
Enterprise software has trained finance teams on a comfortable pattern: a seat costs a fixed amount, consumption is roughly predictable, and the tool’s diligence has no effect on the bill. A CRM that gets used intensively costs the same as one that gets used occasionally.
Agents invert every part of that. An agent plans, loads context, calls tools, checks results, and retries. Gartner’s March 2026 analysis estimates that agentic workloads consume 5 to 30 times more tokens per task than a standard chatbot exchange; researchers at the Stanford Digital Economy Lab found agentic coding tasks consuming up to 1,000 times more tokens than code chat — with the cost driven almost entirely by input tokens the model re-reads at every step, and with runs of the same task varying in cost by up to 30×. The bill scales with activity, and activity scales with ambition — the more capable the agent, the more it attempts, and the more it attempts, the more it spends.
This produces a genuinely counterintuitive property: an agent that struggles costs more than an agent that succeeds. Long reasoning loops, repeated retries, bloated context windows — the failure modes are the expensive modes. In traditional software, inefficiency wastes time. In agentic systems, inefficiency shows up as a line item, compounding invisibly until someone in finance asks why the AI budget is gone in April.
The correction is to stop pricing agents as subscriptions and start pricing them as what they are: operating units with a full cost of ownership. That cost has four layers, and most published ROI calculations only count the first.
The full cost structure of a digital worker
Layer 1: Direct compute. The visible layer — inference costs, API bills, infrastructure. Two properties make it treacherous. First, the price spread between the cheapest model adequate for a task and the most powerful available model runs up to two orders of magnitude, which means routing decisions move the bill more than any prompt optimization ever will. Second, context accumulates: every file an agent reads, every tool response it receives, stays in the session and gets paid for on every subsequent turn. Engineers call it context bloat; at 100K tokens of accumulated context, each message costs real money before the model produces a single word of output.
Layer 2: The harness. By 2026, a consensus has formed among practitioners: in production agentic systems, most of the engineering effort — and a large share of the tokens — goes into the scaffolding around the model, rather than the model’s reasoning itself. Context engineering, evaluation suites, tool integrations, guardrails, versioned domain rules. This is where the recurring finding “a small model with a good harness beats a large model without one” comes from. The harness is also a payroll line: it requires engineers who understand both the domain and the failure modes of language models, and it requires maintenance as models, APIs, and business rules change. Teams that budget for the model and forget the harness typically discover the harness in their second quarter.
Layer 3: Governance overhead. In financial services this layer is structural, and it is the one vendor calculators omit entirely. Workflows where an agent’s output touches money, credit decisions, customer data, or regulatory reporting demand risk-appropriate controls: approval gates where consequences warrant them, audit trails, exception handling, and documented oversight — with the depth of each control scaled to the risk of the workflow rather than applied uniformly. We’ve written before about classifying workflows by risk before agents touch them — the same classification drives cost: the higher a workflow sits on the risk scale, the more supervision expense it carries, and that expense is skilled-human time, the most expensive input in the entire system. An agent that drafts reconciliation reports “for free” but requires forty minutes of senior review per report has a very specific unit cost, and it is nowhere near zero.
Layer 4: The cost of being wrong. In most software, a bug is an inconvenience. In financial systems, an agent error is an incident with a price: a duplicate charge that triggers reconciliation and refunds, a mis-handled KYC path that becomes a compliance finding, a wrong number in a regulatory report. Pricing this layer means estimating error probability and multiplying by consequence — an exercise almost no one performs before a pilot, and the exercise that most changes the answer. It is also the layer that explains why identical agent technology has completely different economics in a marketing team and in a payments team.
Stack the four layers and the real question comes into focus. The question that matters is where, across actual workflows, the full stack of costs drops below the cost of the human alternative.
Where the economics converge — and where they don’t
Run financial-services workflows through the four-layer lens and they sort themselves with surprising consistency.
The economics converge fast in workflows where governance overhead is light and errors are cheap. The pattern they share: the agent prepares, a human approves, and a mistake costs a correction rather than an incident. Here the supervision layer is thin, the expected error cost stays comparatively small, and direct compute plus harness costs are quickly outrun by saved analyst hours. This is also, notably, where the banks profiled in this summer’s agentic-AI coverage — Morgan Stanley, Goldman Sachs, BNY — concentrated their first production deployments. Four fintech workflows show the mechanics:
KYC/KYB evidence gathering. Assembling an onboarding file means pulling registry extracts, sanctions and PEP screening results, ownership structures, and adverse media into one dossier — hours of analyst time per corporate client, spent mostly on collection rather than judgment. An agent compiles the file and flags gaps; the compliance officer makes the decision they were always going to make, from a complete file instead of a half-assembled one. The accountability boundary remains with the compliance function rather than moving to the agent, which is why the supervision layer adds almost nothing on top of the process that already existed.
Reconciliation break investigation. When a payment ledger disagrees with a processor report, the expensive part has never been spotting the break — matching engines do that. It is the investigation: pulling the transaction trail across systems, checking timing differences and fee treatments, drafting the adjusting entry with an explanation. An agent that prepares the investigation file for each break converts a senior accountant’s research hours into review minutes, at a task volume (every break, every day) that amortizes the harness quickly.
Fraud and AML alert triage. Monitoring systems in a mid-sized fintech generate a stream of alerts, the majority of which close as false positives — after a human has assembled the context to prove it. An agent that pre-builds the case file for each alert (transaction history, counterparty profile, prior alerts, matching typology) attacks the largest cost in the entire alert pipeline: paid investigation time on alerts that go nowhere. The economics are set by one variable, visible in the table below — how much context-assembly time the agent removes per alert.
Regulatory reporting — the drafting side. Periodic filings and management reports are pipelines: gather figures from source systems, populate templates, write variance commentary, route for sign-off. The pipeline splits cleanly in two. Data assembly and draft preparation carry the hours and tolerate correction — that half is agent territory today. Submission, sign-off, and final accountability for what reaches the regulator are the high-governance half, and they stay with humans regardless of how good the drafts get. Deploy against the first half and nothing about accountability moves — the oversight the process required was already in it, so the agent adds savings without adding gates.
The common thread across all four: the agent is deployed against the preparation cost of a decision, while the decision itself stays with the human who was always accountable for it. That is where the four-layer math converges fastest, because most of the incremental cost sits in compute and harness rather than newly introduced supervision or error exposure.
The economics converge slowly, or not at all, in workflows that touch discretionary money movement, credit decisions, client-facing advice, or the submission-and-sign-off end of regulatory work. The compute might be trivial; the governance is not. Approval gates, audit requirements, and the fully-loaded cost of errors dominate the equation, and they scale with risk rather than with technology.
The economics of an AI agent in financial services are determined less by model capability than by four cost layers: compute, harness, supervision, and the cost of error. Mapped across common workflows, the pattern looks like this:
| Workflow | Viable autonomy today | Dominant cost layer | Error profile | What drives (or limits) payback |
| Research & meeting preparation | Full — human consumes the output | Compute | Recoverable, low consequence | Saved analyst hours at near-zero supervision cost |
| Documentation & test generation | Full | Compute + harness | Recoverable, caught downstream | High task volume amortizes the harness quickly |
| KYC/KYB data gathering | Agent assembles the file, human decides | Harness | Recoverable if the decision gate holds | Manual-collection hours are the single largest saving |
| Reconciliation & reporting drafts | Agent drafts, human approves | Harness + supervision | Recoverable pre-approval | Draft quality determines review minutes per item |
| Transaction monitoring | Autonomous flagging, human escalation | Harness + supervision | Mixed — false negatives are the expensive kind | Alert precision: every false positive is paid review time |
| Client communications involving advice | Heavy review gates | Supervision | Reputational and regulatory | Review cost scales with message volume, capping the upside |
| Credit decisions | Agent assists, human owns the decision | Supervision + error cost | Regulatory, high consequence | Accountability requirements set a price floor no model progress removes |
| Agent-initiated discretionary money movement | Human approval before execution | Cost of error | Irreversible, incident-grade | Supervision-dominated; automation value sits in preparation, never in the final action |
A qualitative map, based on the four-layer cost model above and the risk criteria we use for delegation decisions (reversibility, blast radius, auditability, accountability) — actual economics depend on task volume, team costs, and regulatory scope. Its purpose is the sorting logic, and the sorting logic is the part that transfers to any workflow this table omits.
Which yields the formula this entire article is built around: supervision costs rise with workflow risk faster than inference costs fall with model progress. Models will keep getting cheaper per token. The human judgment required to safely delegate a credit decision will not get cheaper on the same curve, because its price is set by labor markets and regulators rather than by GPU efficiency. Teams that internalize this stop asking “when will agents be good enough for workflow X” and start asking “what does the supervision stack for workflow X cost, and who pays for it.”
The market data suggests most organizations have skipped this analysis. The State of FinOps 2026 report finds that 73% of surveyed organizations exceeded their AI cost projections even as cost-management maturity rises, and Gartner predicts that over 40% of agentic AI projects will be canceled by the end of 2027, naming escalating costs first among the causes, alongside unclear business value and inadequate risk controls. Those numbers describe a market pricing layer 1 and discovering layers 2 through 4 in production.
The unit economics worksheet
Before any agent pilot in a financial product, four numbers deserve honest answers. Written as questions:
1. What does the task cost with humans today? Fully loaded: time per task × volume × the real hourly cost of the people doing it. This is the baseline the agent must beat — and it hides a subtlety, because the humans doing rote work are often also the ones catching edge cases nobody documented.
2. What does the task cost with an agent — all four layers? Compute per completed task (including retries and failed runs, which the invoice counts even when the demo doesn’t). Amortized harness cost: the engineering to build and maintain context, evals, and integrations, divided across task volume. Supervision cost: minutes of human review per task × reviewer cost — for gated workflows this routinely exceeds the compute. If the pilot can’t measure cost per completed task, that is the first thing to fix.
3. What does an error cost, and how often will one occur? Consequence × probability, estimated separately for recoverable errors (a bad draft) and unrecoverable ones (a wrong filing). In regulated workflows this term can dominate the entire equation — and its size is exactly why the supervision layer in question 2 exists. The two trade off against each other; pretending both are zero is how pilots produce ROI slides that production later refutes.
4. At what volume does the equation flip? Harness costs are mostly fixed; per-task costs are variable. Below some combination of volume and value per task, the engineering investment never pays back — and the break-even point depends on both variables, never on volume alone. Forty low-value tasks a month rarely justify a custom harness; forty tasks a month that each carry $50K of economic exposure may justify a very serious one; and the same harness spread across four hundred tasks a day is a different business case again. The worksheet answer is the product of the first three questions, taken against the fixed cost of building — a threshold each team calculates for itself rather than borrows from an article.
Answering these four questions produces something rare in current AI procurement: a defensible number. It will be less flattering than the vendor slide. It will also survive contact with the CFO. And once the number exists, the next question follows naturally: which parts of it can engineering actually bring down?
The optimization playbook — and its limits
The engineering community spent the past year building a genuine playbook for compressing the compute layer, and the levers are real:
Model routing. Match each task to the cheapest model that handles it. Reported savings range from 30% in conservative production setups to 85% in controlled experiments — the RouteLLM research (LMSYS) demonstrated up to 85% cost reduction while retaining 95% of flagship-model quality. The mechanism is straightforward: many production LLM tasks do not require the flagship model. Routing requires task classification — which, usefully, is the same discipline as risk classification, done once and reused.
Prompt caching. Marking stable prompt prefixes as cacheable cuts costs dramatically — Anthropic’s own documentation cites savings of up to 90% on long prompts, and ProjectDiscovery’s published production case study reports 59–70% total LLM cost reduction after tuning. The catch is break-even math: caching carries a write premium, and below certain hit rates the premium exceeds the savings. Order prompt content from most stable to most variable, and measure hit rate before celebrating.
Context discipline. Kill context bloat at the source: keep sessions scoped, avoid loading entire repositories, compact aggressively, audit what is actually in the window. The cheapest tokens are the ones never sent.
Micro-agents over monoliths. Small, single-purpose agents with defined outputs beat one sprawling agent — for cost, but even more for diagnosability. When a monolith misbehaves, you debug the whole system; when a micro-agent misbehaves, the problem is already localized. Observability is a cost lever, because everything you cannot see, you pay for twice.
Wrapping tool calls in code. Direct tool invocations flood the context with schemas and intermediate results. Having the agent write code that orchestrates tools instead — the pattern Anthropic describes in its “code execution with MCP” engineering write-up — has demonstrated token reductions of up to 98.7% on tool-heavy workflows.
All five can materially reduce compute costs in the right workloads. And here is their limit, stated plainly: token hygiene is optimization, and optimization applied to an unmanaged budget is ritual. If an organization is burning tens of thousands of dollars a month on runaway agent loops, advising it to minify JSON misses the problem by an order of magnitude. At Uber, the missing piece was never a caching strategy — it was that nobody owned the number. Which moves the discussion from engineering to management.
From token hygiene to FinOps: the organizational answer
The engineer’s question is “how do I cut tokens in this session.” The CTO’s question is “who owns this budget line, and why is it unforecastable.” Both are legitimate; only the second one prevents an April surprise.
The organizational answer arriving across the industry is FinOps discipline extended to AI: named ownership of agent spending, showback and chargeback so consuming teams see their own costs, budget alerts and hard limits, anomaly detection for runaway loops, and unit economics tracked per feature rather than per invoice. The FinOps Foundation’s own data captures the shift: per the State of FinOps 2026 survey of 1,192 practitioners managing over $83 billion in annual spend, 98% now manage AI costs — up from 31% just two years earlier — and AI cost management is the #1 skillset teams are looking to add. Its companion finding, the 73% of organizations blowing through AI cost projections, shows how recently the discipline arrived. The tooling ecosystem is racing to catch up: token-level observability is appearing in standard monitoring stacks, model providers have shipped enterprise spend controls with per-model permissions and threshold alerts, and a wave of vendors now exists specifically to attribute agent costs to business outcomes.
The deeper point for engineering leaders: cost predictability is an architectural property. A system built from scoped micro-agents, with routing at the front, caching in the middle, egress and iteration limits at the edges, and per-task cost telemetry throughout, produces a forecastable bill as a byproduct of its design. A monolithic agent with unbounded loops produces an unforecastable one, and no dashboard bolted on afterward fixes that. Teams already design for reliability, for security, for auditability. Cost is now the fourth pillar, and in agentic systems it is designed in or it is absent.
Digital labor is labor
The phrase “digital workforce” turns out to be a precise description rather than a metaphor. Agents have a cost of employment: compute as salary, the harness as onboarding and management infrastructure, review gates as supervision, incidents as the price of delegated judgment. The only thing that was ever wrong with the picture was the belief that any of this comes at subscription pricing.
The past year supplied the tuition: budgets exhausted in a quarter, licenses clawed back, a cancelled-project forecast that keeps climbing. None of it says agents fail to create value — Uber’s engineers kept using the tools through the entire budget crisis precisely because the tools were worth it. It says the winners of the agentic transition will be determined less by who adopts first than by who learns to count first: which workflows clear the four-layer bar, at what volume, under whose ownership, with what ceiling on the cost of being wrong.
At Itexus, we treat agent economics as an architectural constraint alongside reliability, security, and auditability. That means designing for task-level cost visibility, model routing, context efficiency, and risk-based supervision before an agent workflow reaches production scale. Agents that remain affordable at scale are usually engineered that way from the first diagram.
A closing question worth taking to your own team: for your most active agent, what does one completed task cost — and if the answer isn’t known within 20%, which of the four layers is hiding it?
Sources
- The Information — Uber CTO Shows How Claude Code Can Blow Up AI Budgets (April 2026)
- Forbes — Uber Burns Its 2026 AI Budget in Four Months on Claude Code (May 2026)
- Fortune — Uber COO questions AI spending; Microsoft reportedly canceling Claude Code licenses (via The Verge); Gartner’s $207B agent-software forecast (May 2026)
- Fortune — Uber CTO: “the end of the tokenmaxxing era” (August 2026)
- Gartner — Press release: over 40% of agentic AI projects will be canceled by end of 2027 (June 2025)
- Gartner, March 2026 analysis of agentic workloads (5–30× tokens per task vs. standard chatbot), as covered by Cockroach Labs
- Stanford Digital Economy Lab — “How Do AI Agents Spend Your Money?” (Brynjolfsson, Pentland, Pei et al.): agentic tasks up to 1,000× more tokens than code chat; same-task cost variance up to 30×
- FinOps Foundation — State of FinOps 2026: 98% of practitioners manage AI spend (up from 31% in 2024); 73% of organizations exceeded AI cost projections; survey of 1,192 practitioners / $83B+ annual spend
- RouteLLM (LMSYS) — routing research: up to 85% cost reduction at 95% of flagship quality
- Anthropic — prompt caching documentation (up to 90% cost savings on long prompts) and “code execution with MCP” engineering write-up (up to 98.7% token reduction on tool-heavy workflows)
- ProjectDiscovery — engineering case study: 59–70% total LLM cost reduction via prompt caching in production