The standard "Enterprise Finance AI Transformation™" playbook runs about like this: buy subscription seats to Claude or ChatGPT Enterprise, give everyone access to frontier models and desktop harnesses, wire them to email and SharePoint files through MCP servers, run a training or two, and wait for the productivity to arrive.
It usually doesn't.
The shortfall has little to do with model quality, prompting skill, or the depth of the integrations. Your individual employees, especially the ones inclined to push, are probably feeling the AGI already. The trouble shows up one level higher. Organizationally, you cannot point with any confidence to positive ROI, except perhaps in IT. Deloitte's Finance Trends 2026 research puts numbers to it: 63 percent of finance teams have AI fully deployed, yet only 21 percent report clear and measurable returns, even as 87 percent of CFOs call AI an extremely or very important factor in finance and operations this year.
The reason is a matter of aim. Most AI programs are pointed at the edge of the business, while the value companies actually want sits in the core.
The Edge and the Core
The finance teams getting real value run two classes of system, which we call the Edge and the Core.
The Edge is fast and exploratory, the place for the ad-hoc, one-off tasks people reach for in the moment. Copilot, Cowork, and the tools already on every desk, Excel chief among them, live here. The layer is powerful, and it grows more so each month.
It carries a structural limit, though: the Edge generates without remembering. Every session starts cold. The judgment an accountant brings to a thorny reconciliation evaporates the moment the chat window closes, because the work has nowhere to settle. You get more output, and the organization accumulates nothing.
The Core is where the work settles instead of evaporating. It is the AI engine behind the systematic processes of the enterprise: cross-cutting, integrated across systems, governed, and, most important, the place where a firm's workflows, domain knowledge, and hard-won judgment harden into systems that improve with use. The Edge makes a person faster today. The Core compounds.
Two Kinds of Capital
The distinction goes deeper than the usual platform-shift story, and Satya Nadella named why in a recent essay. He argues that earlier digital systems, especially those of the Edge sort, enhanced human capital, and that only now can a genuine cognitive loop form between people and machines, one that changes how work itself is conceived inside a firm. The stakes, in his telling, split into two kinds of capital. Human capital is the judgment and pattern recognition of your people. Token capital is the AI capability you build and own. As token capital grows, human capital does not depreciate against it; it appreciates, because humans still set the goals, connect the domains, and recognize which patterns matter. Strip that direction away and you are left with compute running in circles.
The principle worth holding onto: you can offload a task, even a whole job, but never the learning that comes with it. The Edge takes the tasks off your hands; the Core keeps the learning. That difference is the entire contest.
It also explains why the standard playbook underdelivers. Large companies are rarely held back by individual productivity. They are held back by coordination.
An invoice clears half a dozen approvals before anyone pays it. The monthly close runs a week long because several teams keep their own versions of the same data and burn half their hours reconciling them. The costly work here is not the writing of emails or the building of slides. It is the routing, the reconciliation, the waiting on decisions that have to travel across systems and teams. AI assistants help each person produce more of their part, yet coordination stays exactly where it was. Sometimes it degrades: when every team can generate reports and spreadsheets faster, complexity does not fall, it accelerates. You get more versions of the truth and more artifacts that look authoritative while encoding slightly different assumptions. The organization grows better at producing information and no better at agreeing on it.
We've Seen This Movie
None of this is new. Spreadsheets, departmental databases, SaaS, and RPA each arrived because the core systems could not keep pace with the business, and each bought local relief at the price of fragmentation. RPA was the purest example, an entire industry built to automate the act of clicking through systems that should have been integrated to begin with. Today's AI assistant tends to repeat the move at a higher altitude: automate the edge and leave the core untouched.
The bar should sit higher, because the ceiling does. Software engineers who took up AI are, by their own account, an order of magnitude more productive than they were eighteen months ago, and the Controller's Office has no reason to lag. A head-office accountant should seldom be compiling data or hand-building spreadsheets; the job is to direct and supervise the agents that do that work. That shift demands more than new tools. It demands a different way of operating. The accountant cannot sit on hold for an upstream deliverable, cannot wait a year for a data request to clear IT, cannot work in a silo with no view of the end-to-end processes she touches. It is the same strain now bending Software Engineering's SDLC, where code generation has outrun our capacity to review it.
The Metrics That Matter
You can tell which world a company lives in by the metrics it celebrates. Adoption rates, weekly active users, hours saved per task: the vanity column. What tends to go unmeasured are the outcomes that move the business. Did the close get shorter, invoice processing cheaper, the reconciliation team smaller? Those numbers shift only when the underlying process changes, when the logic moves into a shared system that runs it the same way every time and raises only the exceptions. Helping four teams maintain four versions of the truth more efficiently leaves the reconciliation problem intact. Collapsing them into one version removes it.
This is the property that turns the Core into an asset rather than a line of expense. Nadella calls it a hill-climbing machine: institutional memory becomes queryable, private evaluations measure whether the model is improving against the outcomes a business actually cares about rather than public benchmarks, and the firm's own execution traces make each run a little better than the last. Unlike most assets, it compounds. Every improved workflow throws off better signal, and that signal speeds the accumulation of tacit knowledge no competitor shares.
The Core Has to Be Software
Look closely at what the hill-climbing machine optimizes. In the end, Nadella's version is an engine for producing better tokens: it gathers context, sharpens the evaluations, and feeds the result back so the next answer comes out a little less wrong. For much of the business, that is the right destination. Finance cannot follow it there, because approximately correct does not close the books. A general ledger that ties out 97 percent of the time is a liability with a confidence interval.
The right conclusion to draw is not that ERPs were a mistake. An ERP is a deterministic, integrated, auditable system of record, and that determinism is precisely what you want; no one is asking for a probabilistic close. The failure was never architectural. It was economic. Because everything in the system connects to everything else, the blast radius of any single change is enormous, so each improvement has to pass through a waterfall project, a cohort of specialists, and the regression risk that comes with touching a monolith. The math rarely works, and the core freezes in place while the business moves on around it. ERPs did not ossify because they were badly built. They ossified because they were built to change slowly, by experts, at great cost.
The bar for a new core, then, is specific: keep the determinism and shed the rigidity. What your accumulated judgment compiles down to should not be a fatter prompt. It should be code, deterministic and legible and cheap to run, the Excel spreadsheets we know and love, except governed, version-controlled, and maintained by the system itself. Your SOPs, context graphs, execution traces, and private evaluations are the raw material. The product is software that runs each process the same way every time, raises only the exceptions, and rewrites itself as the business and its environment change, tendering the revision, proving it against the evals, and shipping it. The goal is an autopoietic system, one that assembles and organizes and optimizes itself toward the best execution at the lowest cost, yet stays legible, bound by CPU and IO rather than by inference, the kind of system where you can always read the formula in the cell.
Inference does not vanish in this design; it gets aimed. You spend tokens on the ambiguous frontier, on the novel call and the messy exception and the judgment you already entrust to your most senior people and your global capability centers, and you let the settled, repeatable work fall through to compiled code that runs for a fraction of a cent. This is also how the P&L finally moves. You stop paying a model to re-derive last month's reconciliation logic every month; you pay for the thinking once, and the program runs for next-to-nothing after that.
Re-deriving a settled process on every run pays twice for the same reasoning and bets, each time, that the answer holds. It is a calculator that bills you to reconsider whether two and two make four, and now and then returns five.
Here our path diverges from the platform vendors. The divergence follows from their business model, not from any flaw in it. Microsoft, the hyperscalers, and the frontier labs all sell tokens and inference, metered, in perpetuity. For the Edge, that is a fair trade. For the Core, the destination runs the other way: less inference over time, not more, as the work hardens into code you own. The same logic answers the anxiety every enterprise feels about betting on one model. Expertise that lives in a context window is rented by the token and tethered to a vendor's roadmap. Expertise that lives in the Core as code mostly never calls a model at all, which lets you swap the generalist underneath without losing the company veteran your system has encoded. That portability is what sovereignty will mean in the years ahead. It is the line between a frontier economy where value flows out across every industry and one where a few models commoditize the world's hard-won knowledge out from under it.
The Work
Ride the Edge, then. It will keep getting faster, and your people should feel every bit of it. But speed at the Edge is a thing you rent by the day; the Core is the thing you come to own. The work ahead is to build the loop in which human judgment compiles into code, and the code in turn frees your people for the only work that truly needs them, which is the next judgment. That loop is the asset. Build it in the Core, because it can not live anywhere else.