FinOps for the Agentic Enterprise

FinOps for the Agentic Enterprise

May 2026

The Old Model Is Breaking

Here's how FinOps has worked for a decade:

1. A human provisions a resource
2. That resource shows up in a cost dashboard
3. Another human reviews the spend
4. Someone sets a budget, tags it, maybe right-sizes it
5. Repeat monthly

This model assumes a human is in the loop at every decision point. A person decides to spin up a cluster. A person reviews whether that cluster is still needed. A person approves the budget increase.

That assumption no longer holds.

In the agentic enterprise, AI agents autonomously provision resources, make API calls, scale workloads, and spawn sub-tasks — all without a human deciding to spend money. The "spender" is software. And it doesn't check Slack before it scales.

What Makes Agentic Spend Different

Traditional cloud spend is deterministic and resource-based. You provision a VM — you know what it costs per hour. You can forecast it.

Agentic spend is probabilistic and outcome-based. An agent gets a task. How much it costs depends on:

• How many reasoning steps it takes
• How many tools it invokes
• Whether it retries on failure
• How much context it carries between steps
• Whether it spawns sub-agents to parallelize work
• Whether it enters a loop nobody anticipated

A single agent task can cost $0.03 or $30 depending on complexity, model choice, and runtime behavior. Multiply that by thousands of agents running autonomously across an enterprise, and you have a cost surface that no human can manually govern.

The Compounding Problem

Agentic architectures have a compounding cost dynamic that traditional cloud doesn't:

• Agent A calls a model to reason about a problem → tokens consumed
• Agent A decides it needs data, calls Tool B → API cost + more tokens to process the response
• Agent A realizes the task is complex, spawns Agent C → duplicate context injection + new token stream
• Agent C fails, retries 3 times → 3x the cost of success
• Agent A synthesizes results from Agent C → more tokens to read and summarize

One "task" just generated 6-10 billable events across 3 systems. The person who triggered it? They clicked one button.

Why Traditional FinOps Fails Here

The fundamental shift: FinOps must move from governing resources to governing decisions.

What Cost Governance Looks Like When the Spender Isn't Human

1. Budget at the Agent Level, Not Just the Team Level

Every agent deployment needs a token budget — per task, per day, per month. Hard caps with escalation:

• Soft limit: Alert the owning team when an agent hits 80% of its daily budget
• Hard limit: Pause the agent and require human approval to continue
• Circuit breaker: Kill the workflow if spend exceeds 10x the expected cost (loop detection)

This is the equivalent of IAM policies for spend. You wouldn't give a service account unlimited AWS permissions — don't give an agent unlimited token access.

2. Classify Agents by Risk Tier

Not all agents carry the same cost risk:

3. Implement Model Routing as a Cost Lever

Most enterprises run every agent call through their most expensive model. This is like running every workload on p4d.24xlarge instances.

A model routing layer should:

• Route simple extraction/classification to small, cheap models (cost: $0.10-0.50/M tokens)
• Use mid-tier models for general reasoning (cost: $1-5/M tokens)
• Reserve frontier models for genuinely complex reasoning (cost: $10-75/M tokens)
• Cache common queries to avoid redundant inference entirely

Organizations implementing model routing report 40-60% cost reduction with negligible quality impact on lower-tier tasks.

4. Track Unit Economics Religiously

The question isn't "how much did we spend on AI this month?" — it's "what did we get for it?"

Define unit economics for every agent workflow:

• Cost per ticket resolved (customer support agent)
• Cost per PR reviewed (code review agent)
• Cost per lead qualified (sales agent)
• Cost per report generated (analytics agent)

Then compare against the human baseline. If your AI agent costs $4.50 to resolve a support ticket that a human resolves for $12, that's a win. If it costs $47 because it's over-reasoning and calling tools unnecessarily, that's a design problem masquerading as a cost problem.

5. Build Observability Into the Agent Architecture

You can't govern what you can't see. Agentic observability requires:

• Per-call logging: Every model invocation, tool call, and sub-agent spawn — tagged with workflow ID, owning team, and business context
• Cost attribution: Real-time spend tracking at the agent, workflow, and department level
• Behavioral baselines: What does "normal" look like for this agent? Flag deviations.
• Outcome correlation: Tie token spend to task completion. Did the spend produce value?

This is your new cost dashboard. It doesn't show you VMs and storage — it shows you agent workflows, their token consumption, their success rates, and their cost-per-outcome trends.

6. Govern the Agent Lifecycle

Agents shouldn't just appear. Treat them like production services:

• Registration: Every agent gets cataloged with its purpose, expected cost profile, owning team, and risk tier
• Approval: Tier 2-3 agents require architecture review before deployment (including cost modeling)
• Monitoring: Continuous spend tracking with automated alerting
• Retirement: Unused or underperforming agents get decommissioned — just like idle infrastructure

By mid-2026, enterprises have an estimated 3+ million AI agents running — with only ~47% actively monitored. That's 1.5 million unmonitored autonomous spenders. This is shadow IT all over again, except the shadow resources make their own decisions.

The Organizational Shift

This isn't just a tooling problem — it's a people and process problem.

FinOps teams need new skills: - Understanding token-based pricing models - Evaluating LLM cost/performance tradeoffs - Reading agent execution traces (not just cloud bills) - Partnering with AI/ML teams on architecture decisions

Finance needs new mental models: - AI costs are variable and outcome-correlated, not fixed and time-correlated - "Budget variance" means something different when an agent can 10x its spend in a day for legitimate reasons - Forecasting requires understanding adoption curves, not just resource reservations

Engineering needs new accountability: - Agent designers own cost efficiency the way backend engineers own latency - "It works" is not sufficient — "it works within budget" is the bar - Cost is a non-functional requirement in agent design, not an afterthought

What Comes Next

The enterprises that figure out agentic FinOps will deploy agents confidently and scale them efficiently. They'll know exactly what each agent costs, what value it delivers, and when to invest more vs. pull back.

Everyone else will be explaining to the CFO why AI spend tripled in Q3 with no clear ROI.

The playbook: 1. Get visibility now (audit what's running and what it costs) 2. Set guardrails (budgets, caps, circuit breakers) 3. Establish unit economics (cost per outcome, not cost per token) 4. Build routing and optimization (right model for the right task) 5. Create lifecycle governance (register, monitor, retire)

The agents are coming whether FinOps is ready or not. The question is whether you govern them — or get the bill after they've already spent.

Trey Morgan is a cloud FinOps leader based in Austin, Texas. He previously led FinOps product strategy at Microsoft and Walmart, and currently drives Cloud FinOps as a Service delivery. Connect with him at treymorgan.com.