Join the community for Tokenomicon + FinOps X Amsterdam, Sept 22-23
Register now
FinOps Foundation Insights

Agentic FinOps: Why Adoption is Slower Than the Conversation

Dean Oliver
Dean Oliver
August 18, 2026
Agentic FinOps: Why Adoption is Slower Than the Conversation

Key Insight: Most FinOps practitioners have not yet adopted AI agents because making them useful requires greater organizational context, while allowing them to act requires delegated authority. Both increase the challenge of implementation, trust and governance. Where adoption is progressing, practitioners start with narrow, bounded use cases, define limits through policy rather than prompts, keep execution controlled or reversible where needed, and expand authority only as evidence and confidence grow.


The Gap Between Agent Interest and Adoption

In March 2026, a question about how to build a FinOps agent received a single answer describing slow progress well outside the practitioner’s own skill set. In May 2026, asked why the topic stayed quiet, a practitioner replied that few people outside vendors are building this, and the common approach is to buy a tool and rely on the supplier having solved the hard parts.

Five Common Reasons Adoption Progress is Slow

  1. The value is unclear. Many agent examples surface information practitioners already have, just in a chat box instead of a chart. As one practitioner put it, how many more tools do we need to tell us the same thing we already know from twenty other places?
  2. The agent may not have enough context to make the decision. Building useful agents requires FinOps teams to develop new skills in designing, testing and operating them safely. But the bigger organizational challenge may be context. A useful agent may need to reason across cost, usage, budgets, contracts, architecture and operational systems before it can make a useful decision. That information is fragmented across teams and systems, while security, data ownership and governance boundaries restrict how much can be brought together or accessed by the agent.
  3. The numbers are not always reliable, and the practitioner carries the exposure. The most detailed community build example included sensible safeguards, including explicit instructions never to invent figures. It still produced fabricated cost numbers and sometimes answered without checking the underlying data. If an agent makes the wrong recommendation or triggers a production change, accountability still sits with the function and people operating it.
  4. Nobody can say what the agent is permitted to do. Most FinOps practices do not have authority to move from reporting cost issues to fixing or preventing them. Practitioners described needing standing authority, written policy and business and security sign-off even for actions such as switching off development servers. Giving that authority to an agent therefore creates an identity and accountability problem, requiring clear ownership, bounded permissions and auditable actions.
  5. The running cost cannot be forecast precisely. Traditional automation follows a known execution path. An agent investigating unusual cost may take five steps or create dozens of tasks before it is satisfied. Its own cost is therefore variable, and poorly bounded agent loops can continue consuming resources long after the value of the task has been exhausted.

The tension at the heart of the problem. An agent becomes more useful as it gains context and authority, and harder to trust and govern for exactly the same reason.

What “Agentic FinOps” Actually Covers

A community member asked me directly in July what “Agentic FinOps” means.

The distinction that matters is who decides what happens next. Was the sequence written down by a developer in advance, or can the model choose its next action based on what it observes?

From there, there is a spectrum from deterministic automation to bounded autonomy. The levels differ by how much control the model has over the path, and how much authority it has been given.

Level 0

Not an Agent

Follows hardcoded rules written directly by a developer. Zero dynamic decision-making.

Example

A console button that auto-writes a cost query or returns a fixed recommendations list.

What it can change

Nothing (static)

Level 1

Picks Route

Dynamically chooses the optimal model or path based on system rules or prompt complexity.

Example

Routing easy queries to cheaper models and complex ones to premium models.

What it can change

Nothing (read-only)

Level 2

Picks Evidence

Investigates issues autonomously, searching live systems to diagnose structural changes.

Example

Tracing a budget spike to infrastructure modifications and specific code commits.

What it can change

Nothing (analysis only)

Level 3

Runs a Team

Orchestrates workflows by dividing complex tasks among multiple specialist AI components.

Example

Running automated audits where components flag anomalies, tag gaps, and draft summaries.

What it can change

Drafts only (no actions)

Level 4

Acts within Limits

Modifies production infrastructure autonomously within strict, predefined guardrails.

Example

Resizing a database: backing up, stopping, scaling, verifying, and rolling back on failure.

What it can change

Controlled production

Only the final level has authority to take or initiate changes within delegated limits. That does not mean the model itself has to execute every change. An agent can decide what should happen within approved guardrails, while deterministic automation performs the action. When discussing a “FinOps Agent”, the first question should therefore be: which level of the spectrum?

There is a separate choice about where the agent comes from, and it is independent of its level of agency. Cloud providers now ship agent capabilities inside their own consoles and cost tooling, which is quickest to start but usually scoped to one provider. Third-party cost platforms expose their own agent features over data you have already normalized. A team can also assemble its own using open connector standards, giving wider reach across billing, monitoring, ticketing and source control, at a higher build and security burden.

The decision depends on your FinOps Scopes, the complexity of your technology landscape, how many providers you run, whether your cost data is already consolidated, what context your organization will permit an agent to access, and separately, what authority it is prepared to delegate to it.

Four Recurring Patterns for Bounded Agentic Action in FinOps

There are documented examples of agents operating with meaningful autonomy in FinOps, many of them shared at the recent FinOps X 2026 in San Diego during breakout talks.

But the more transferable pattern is not giving an AI model broad control of production infrastructure. It is finding areas where the agent can be given a narrow decision space and genuine authority without taking ownership away from the teams already responsible for the underlying systems.

01

Narrow Decision Space

Avoid broad "optimize cloud" mandates. Give the agent a specific job with clear boundaries and a measurable outcome.

  • Update an agreed forecast when defined conditions change
  • Collect evidence for a specific FinOps decision

02

Policies Define Limits

The agent can reason about what should happen, but it does not define its own authority. Approved policy sets the boundaries.

  • Apply approved changes to deployment policy controls
  • Update runtime guardrails within predefined parameters

03

Evidence Before Action

Where another team owns the decision, let the agent assemble the evidence and target the action rather than make the change itself.

  • Combine cost, usage and operational evidence
  • Route optimization recommendations to the responsible engineer

04

Controlled Execution

Once an action is approved or explicitly delegated, use existing workflows and deterministic automation to carry it out and record the outcome.

  • Update approved controls or workflow state
  • Trigger, log and verify the agreed action

That could mean updating an agreed forecast when defined conditions change, collecting evidence across cost and operational systems, applying an already approved policy change to deployment or runtime controls, or automatically targeting an optimization recommendation to the right engineer with the evidence needed to make the decision.

The last example is already visible in practice. A global financial services organization described an agentic rightsizing workflow that reasons over a recommendation, checks CPU and network history, and files the change ticket for Engineering rather than making the infrastructure change itself.

Taken together, the pattern is not that these teams have solved the reliability problem. They have reduced how much reliability has to carry. The decision space is narrow, policy defines the limits, evidence is gathered before action, and execution remains human-gated or deterministic where the risk requires it.

This also provides a practical path toward Acts within Limits. FinOps teams can first delegate authority over FinOps-owned workflows and controls, then extend that authority outside of their current remit only where the evidence, organizational trust and policy allow it.

Where to Start with Agentic FinOps

Each step reduces the cost and consequence of being wrong.

  1. Write down what your practice may already do without asking. If that list is short, it is your ceiling. Raising it is an organizational conversation rather than a technology purchase.
  2. Begin with investigation, not action. Have an agent collect evidence across cost, usage and relevant operational systems to explain why something moved. Being wrong here is comparatively cheap, and it is where reasoning adds most over a static report.
  3. Test on cases where you know the answer. Replay past anomalies. Did it find the real cause, invent anything, stop when it should, and what did it cost to run?
  4. Route the first changes through your existing review process. Have the agent propose rather than perform, using an approval path the organization already trusts.
  5. Then earn bounded action, one use case at a time. Start with something narrow where authority can be explicitly delegated. Put the limits in policy rather than the prompt, verify the outcome and make actions reversible where needed. Add a spending cap and a step limit, because in FinOps an agent that loops without end is not just slow, it is expensive.

Topics

  • FinOps Foundation Perspectives
Related assets
padded

AI for FinOps: Agentic Use Cases in FinOps

padded

Who sets the AI budget?