Shifting AI: experimentation to trusted output

AI works, but at what cost? Smart companies are moving to govern consumption without sacrificing developer speed

In brief

• How companies can control AI costs in real time without slowing developer speed.
• How leaders can prove AI productivity gains translate into trusted business value.
• What operating model can govern model routing, token use, agents and cost at scale.

The pivotal move from access to consumption

This pressure is already impacting how AI is being bought, deployed and scaled. The market is no longer optimizing for access to AI. It is struggling with how AI is consumed.

This focus shift from adoption to control is the result of AI’s success. Developer tools, coding agents, copilots and internal assistants are spreading across teams, while enterprise AI architecture becomes more distributed.

AI execution has rapidly moved away from a single endpoint with a predictable bill. Work moves across cloud models, open-weights models, local environments, private routes and agentic workflows. This shift becomes more complex as AI moves from single-point tools to distributed, agentic execution models.

Consumption is no longer tied to a single request. It is shaped by where work runs, how agents operate, and how many steps they take to complete a task. The impact is being felt in pricing, too.

Premium frontier models may cost more per token, but they can be a smart choice if they reduce failed cycles. Lower-cost models may save money on a single call, but they can become more expensive per completed task if they trigger more retries and produce less trusted output.

As AI moves deeper into engineering workflows, cost becomes a variable operating line tied directly to developer behavior and agent design. Without controls, routine actions — especially long sessions, retries and parallel agents — can multiply consumption in ways that are difficult to predict or govern.

Today’s bottleneck is control, not access

The push to utilize AI across the enterprise was a necessity in the early days. It clearly worked; adoption has been rapid and pervasive, and AI has proven it makes developers faster. Most companies report measurable productivity gains.

Now the issue is whether the economics can hold. Companies need to be able to see, decide, route and limit AI consumption in real time, before costs are incurred. Without that control, it’s difficult to measure whether enhanced productivity is truly benefiting the bottom line.

The fear surfacing in boardrooms, CIO councils and engineering reviews is that AI is scaling a new, unmanaged source of variable cost. The time is right for AI to move from broad experimentation to economic control — without slowing development.

Examples of large-scale agentic systems are early signals of how quickly AI consumption can scale when autonomy is introduced. But while speed is visible, cost accountability is not.

Without control, ordinary developer behavior can drive disproportionate cost:

• Long sessions expand context and increase token usage
• Agent workflows multiply requests through retries and validation
• Frontier models are applied to routine work
• Parallel agents scale spend faster than outcomes can be evaluated

These outcomes aren’t a surprise given that broad AI usage is relatively new, even at technology companies. What they point to isn’t poor engineering design or a developer behavior problem; rather, they are the result of missing operating controls. For FinOps leaders, the critical metric is connecting cost to the volume of trusted engineering output being achieved.

These measures are illustrative until the organization sets its own baseline:

• Cost per accepted change
• Cost per successful task
• Retry-adjusted cost per outcome
• Quality-adjusted output
• Frontier route percentage
• Local and open-weight route percentage
• Cache hit rate and avoided input cost
• Agent-loop cost

Together, these measures can convert an open-ended bill into a budgeted dollar amount that leaders can plan against and hold accountable.

What the enterprise needs

Solving this challenge is a systems problem requiring operating models — not guidelines, not dashboards and not after-the-fact reporting.

Enterprises need a control system that can:

• Observe AI usage in real time
• Estimate cost before execution
• Route work intelligently
• Enforce limits dynamically
• Learn and improve from outcomes

At Ernst & Young LLP, we call this system an AI Consumption Control, enabled by the Autonomous Closed-Loop Control Framework (ACCF).

ACCF is not a label for a dashboard. It is a control loop. It separates the business intent, the observed signals, the computation, the governed decision, the action taken and the evidence used to improve the next decision.

In practical terms:

Of course, not all AI consumption behaves the same.

Software development is where these dynamics are most pronounced because the work is iterative, contextual and increasingly agent-driven.

A single development task can involve multiple loops of generation, testing, revision and validation. Each step adds value but also adds cost, context and complexity.

Because blunt controls fail in this environment, the solution is implementing layered, intelligent controls across the development lifecycle to manage FinOps expense without slowing development:

• Demand — Decide whether AI is needed for the task.
• Session — Keep long sessions from making every later turn expensive.
• Route — Reserve frontier models for work that needs frontier reasoning.
• Local execution — Use local, private, open-weight or lower-cost models where quality and policy allow.
• Context — Send the smallest useful package of code, symbols, history and instructions.
• Cache — Measure whether cache is paying back.
• Agent behavior — Stop loops, repeated reads, excessive retries and uncontrolled parallelism.
• Portfolio risk — Avoid overdependence on one model provider, model tier or proprietary route.
• Evidence — Record what was used, why it was used and whether it produced trusted output.

All of this leads to the most important design decision: When control happens is just as important as what is controlled.

ACCF separates control into three timing paths to enforce economic discipline without slowing down development work:

Shifting focus from experimentation to advantage

The best approach to implementing ACCF is to begin with a high-volume AI development workflow, measure before restricting and then introduce controls in stages:

• Define guardrails for tools, models and token limits.
• Route routine work away from high-cost models. Use local, private, open-weight or lower-cost models for approved low-risk work.
• Reduce context to only what is necessary.
• Govern cache based on actual return.
• Detect agent inefficiencies early.
• Evaluate premium frontier routes by cost per trusted outcome.
• Create a FinOps operating model for model routes, reserved capacity, budget exceptions and unit economics.

To maintain cost discipline and manage budget risk while achieving short- and long-term development goals, enterprise technology leaders should maintain a focus on productivity — but demand proof that it pays back.

After all, AI is already making your developers faster. That is no longer in question.

What matters now is whether that speed translates into controlled, repeatable economic value — or into a cost curve that scales faster than you can manage. Because in an agentic world, you are no longer just deploying software. You are deploying autonomous consumption at scale. Every unit of AI consumption should be intentional, visible and accountable to business outcomes.

In a few short years, the AI objective has changed considerably. We know today that the organizations that win will not be the ones that adopt AI the fastest. They will be the ones that control how AI works, where it runs and what it costs — before those decisions become irreversible spend.

Moving your company’s AI focus from broad experimentation to a governed, economic advantage is the key.