Enterprise AI spending is evolving in ways many finance and engineering leaders did not anticipate. The unit price of a token continues to fall, and yet overall AI spending continues to climb. Teams that believed they had consumption under control are finding that a routine model upgrade can double or triple usage within a single billing cycle, with no change in the number of people using the system or the volume of work produced.
The common response is to treat this as a commercial problem and return to the provider to seek better rates. In most cases, that addresses the wrong variable. Cost volatility like this often stems from how AI has been architected into the delivery system, exposing a gap in how engineering organizations are staffed.
AI-native software delivery is no longer a future state to plan for. It is already in production environments, where copilots are used daily, agents write and run tests, and AI drafts requirements, generates documentation, modernizes legacy applications, and augments security reviews. The more useful question is whether an enterprise is leading that change deliberately or absorbing it one tool and one experiment at a time. Cost volatility is often the first visible symptom of the latter, but it is rarely the only one.
See also: The Democratization of AI: Why No-Code Is the Bridge Between AI Capability and Business Execution
A gap in the delivery organization
Consider how responsibility is distributed in most large delivery organizations. Enterprise architects own the architecture, platform engineers own the development platforms, DevOps teams own pipelines and releases, AI engineers build models and agents, and product teams own the roadmap. Each role is well defined and remains necessary, but none currently owns how AI is changing the engineering system as a whole.
That gap is now visible across industries because AI does not confine itself to a single layer of the stack. It changes requirements, architecture, testing, knowledge management, and governance, as well as the economics of each. Someone has to be accountable for that end-to-end redesign, considering business process, context, data, and platforms together rather than in isolation. Far from reducing the need for architecture, AI increases it. Most enterprises will have comparable access to capable models; the difference will be in the engineering system built around them.
The AI-forward engineer is a senior, hybrid role. It is distinct from the forward-deployed engineer model, which has been widely adopted over the past two years. Forward-deployed engineers work closely with customers to build, configure, integrate, and deploy technology within complex environments. AI-forward engineers have a different mandate: They focus on the engineering system itself and how the organization uses AI to solve business problems, build software, drive adoption, and manage the economics of all three. Both roles are valuable, but they solve different problems, and conflating them can cost organizations time.
See also: Exploring the Sovereign AI Aspects of Inference Servers
The profile of this role
The engineers who succeed in this role share a common profile. They are senior solutions architects who have pivoted and been working AI-natively for at least two years, with genuine technical depth in architecture and Python, and often have experience inside one of the major cloud ecosystems. However, business context matters. Domain depth matters. An engineer rooted in manufacturing, for instance, understands the processes and the contextual nature of the data before an AI layer is placed on top, and that grounding is what separates a redesigned process from an automated version of a poor one.
The role is also highly consultative, with much of the work focused on helping people adapt how they operate rather than building systems in the background. Conventional training, such as a one-time session on how to use a particular assistant, is not enough to sustain change. Lasting adoption requires changes in everyday habits: for example, helping a project manager determine how AI can improve how they plan, estimate, and report, and then making those practices routine.
This distinction matters because coding accounts for only about 20% of a software project, with the remainder consisting of planning, requirements, testing, knowledge transfer, and knowledge management. Organizations that equate AI in engineering with code assistants are optimizing the smallest share of the work. It also helps explain why their gains so often fail to appear at the program level.
The role belongs within the CTO organization, though it functions only if the business trusts it. Not since the early days of SaaS has it been this easy for business units to acquire technology on their own. Every software provider now offers AI features and licensing, and business teams can build working applications themselves, producing a growing volume of AI capabilities that bypass IT entirely. An AI-forward engineer can credibly reconnect the two sides by bringing together the business’s process knowledge and engineering’s architectural discipline.
Why the bills come as a surprise
Two shifts account for many of these surprises. The first is commercial. Enterprise software conditioned buyers to think in terms of seat licenses: a fixed cost per person per year, often with effectively unlimited use. AI introduces usage-based pricing and, in many cases, a combination of license and consumption charges. The result is a fundamentally different cost model, and budgeting practices designed around predictable per-user licensing do not translate cleanly to consumption-based AI.
The second shift is technical, and it is one that engineering teams tend to underestimate the most. Token consumption is a function of architecture rather than headcount. The model required to generate and refactor code is not the same as the model required to draft an end-of-project summary, yet most organizations route both to whichever option is newest and most capable. In practice, people default to a model considerably more powerful than the task demands. Multiplied across thousands of calls a day, the resulting bill bears little relation to the published price per token.
Agent design can compound the effect because agents may loop through tasks, recheck one another, and apply unnecessary reasoning to straightforward steps. Without careful architecture, those behaviors can increase both token consumption and processing time.
The consequences are not marginal. In one financial services legacy modernization program, token costs exceeded the budgeted figure by more than five times, forcing the program to pause. Three changes brought it back under control. First, engineers received advanced training in working with the models, which proved more impactful than expected: Teams without that training spent about four times as many tokens to perform the same work. Second, the team rearchitected the workflow around a hybrid design, using AI only where it added value. Rather than applying AI at every step, the team used AI to generate test cases and deterministic automation to execute them. Third, the team matched different types of work to the appropriate model class. Token spend fell to roughly a fifth of its peak, while workflow processing time dropped from six hours to 50 minutes. The lesson is clear: Reducing AI costs and improving performance often go hand in hand. Both depend on designing an architecture that uses AI reasoning where it adds value, and the figures point to the same lesson: AI cost and processing time are often driven by the same thing: using AI reasoning where it isn’t needed. Designing the architecture to use AI only where it adds value can improve both.
Governing cost and behavior at runtime
A monthly invoice is a lagging indicator. By the time it arrives, the system may already have made millions of routing decisions, while the architecture responsible for the overage continues to run. If AI cost is treated primarily as a finance reconciliation exercise, problems may not surface until a full billing cycle closes. Teams therefore need to instrument and manage consumption, model selection, and agent behavior within the workflow itself, alongside latency and error rates, within the same time frame as the work is performed.
In practice, this means governance that operates at runtime rather than in a policy document. Tiering is a recommended approach: categorize users by role and by historical usage pattern, then match each tier to a defined set of models and consumption ceilings. An executive drafting a summary and a security analyst running deep code analysis do not belong in the same category. A small number of tiers can cover most of the workforce. In one large organization, six tiers proved workable for matching people to models based on their roles and historical usage patterns.
Ceilings let teams cap spend before a cycle closes, but the more useful control is which models each tier can see, since most people will use whatever is presented to them as the newest option. Curating that menu is a more dependable form of cost control than asking individuals to choose frugally, and it removes a decision most users are not equipped to make.
The same logic applies to trust. Once agents are generating code, tests, and documentation, questions about where they are permitted to act, where a person remains in control, and what evidence is required before their output is accepted cannot be settled in a quarterly audit. Those rules have to be enforced in the pipeline, at the point the output is produced. Determining where AI belongs within DevSecOps is the same class of problem as determining which tier sees which models. Both are forms of runtime governance, and in most organizations, neither has an owner.
Optimization depends on a baseline
Organizations cannot credibly demonstrate that AI has improved a business process if they cannot first describe how that process performs today. Without a clear baseline, improvement claims remain difficult to substantiate.
A usable baseline is broader than cost alone, covering data readiness and the interoperability of the systems involved, the organization’s readiness to absorb the change, and the governance, risk, compliance, and regulatory constraints attached to the use case. Many programs stall when an organization seeks to transform a process without a shared understanding of how it operates today. Without that baseline, there is no agreed starting point to measure the redesigned process against. Establishing that starting point makes return on investment calculable, not merely asserted.
The metrics should come from engineering rather than finance alone. Tokens per unit of work is one input. Alongside it sits delivery lead time, cycle time, automation rate, and review rate, agreed upon before the program begins and reported continuously thereafter. Two years ago, telling a board that the organization was implementing AI was an acceptable answer. That’s no longer true; boards now expect results, which requires instrumentation from the outset.
The future of the role
The description of the AI-forward engineer will likely look different in two years as responsibilities evolve and AI absorbs parts of the work, although the underlying mandate should remain. One emerging agentic AI question is how organizations provision, train, evaluate, govern, and ultimately decommission agents. In many respects, this is a workforce management problem expressed in engineering terms, and most organizations do not yet have a clear owner.
None of this removes the cost question. Token prices will keep falling, capabilities will keep evolving, and each release may change the consumption profile of systems tuned for the model that preceded it. What organizations can control is the engineering system that connects their business processes to the models they use, and that system requires an owner. Organizations need to understand not only how to use AI, but also how to engineer the systems around it. Token prices are not the variable that matters. The AI architecture is, and right now in most enterprises, nobody owns it.