There is a moment in every technology cycle when the market stops asking "what can this do?" and starts asking "what should we build ourselves?" That moment arrived quietly for enterprise software in 2026, marked by a single data point that deserves more attention than it received: 32% of organizations have decided to skip buying off-the-shelf software entirely, choosing instead to construct their own tools using agentic coding systems.
This is not a footnote in a McKinsey slide deck. It is a signal that the fundamental architecture of how enterprises consume software is being renegotiated. When nearly a third of companies look at the existing SaaS landscape and say "we can build it better with AI," the traditional software value chain begins to crack. And in the cracks, a new ecosystem forms.
Let me contextualize this within the broader liquidity map. For years, the enterprise software market operated on a simple premise: buy the best tool, integrate it, pay the subscription. But the agentic coding shift inverts this. Instead of purchasing a finished application, enterprises now purchase the capability to build — model APIs, development frameworks, cloud primitives, and orchestration layers. This is the financial equivalent of moving from buying a car to buying a factory that can produce any vehicle on demand. The unit of value is no longer the product; it is the production process itself.
What makes this moment particularly compelling is the stark asymmetry in outcomes. MIT NANDA's research reveals a chasm: internal build attempts succeed only 33% of the time, while purchasing vendor tools yields a 67% success rate. On the surface, this suggests enterprises should simply buy. But the deeper narrative is more nuanced. The high performers — those generating at least 5% of EBIT from AI — are nearly twice as likely to skip software purchases entirely. They are not building because it is easy. They are building because they have acquired the system engineering capabilities that make building viable: internal model fine-tuning pipelines, evaluation suites, and observability infrastructure.
This is where my own audit experience sharpens the picture. In my years analyzing tokenomics and protocol architectures, I have seen this pattern before. The projects that survive bear markets are not those with the flashiest whitepapers, but those with the most robust feedback loops — mechanisms to catch errors, iterate, and improve. The same applies here. A 33% success rate for internal builds is not a condemnation of the approach; it is a reflection of which organizations possess the discipline to treat AI coding as a system engineering challenge rather than a magic wand deployment.
The cost dimension adds another layer of texture. McKinsey reports that 20% of organizations already feel the pressure of AI operational costs. Agentic coding workflows are notoriously token-hungry — a single task can trigger dozens or even hundreds of LLM calls, each burning inference dollars. This is the hidden tax of autonomy. The most successful organizations, as McKinsey's partner astutely notes, treat operational costs as a design constraint rather than an afterthought. They employ model routing — sending simple tasks to small models, complex ones to large — and implement caching strategies that would make any DeFi yield optimizer proud.
Here is the contrarian angle that most analysis misses: the real winners in this shift may not be the flashy AI coding assistants at all. Cursor, Replit, and Cognition dominate headlines, but the structural value is accruing to the intermediation layer — the platforms that help enterprises fail less. The 67% success rate of vendor tools is not an accident of superior code generation; it reflects embedded safety rails, evaluation frameworks, and governance structures that internal teams often underestimate. The market is quietly rewarding those who reduce friction and failure risk, not those who maximize raw capability.
There is a poetic symmetry here with the blockchain world I inhabit daily. In crypto, we learned that self-custody is powerful but dangerous; the majority of users prefer trusted intermediaries. The same dynamic is emerging in enterprise AI. The 33% internal build success rate is the "self-custody" of software development — liberating but unforgiving. The 67% vendor tool success rate is the "regulated exchange" — safer, more compliant, but less flexible.
The implications for the broader software economy are profound. Traditional SaaS companies face a structural compression of their addressable market. Why buy a $50,000-per-year CRM when your internal team can build a custom solution tailored to your exact workflow? The answer, for most firms, remains "because you'll likely fail" — but that equation shifts as the infrastructure matures. Cloud providers and model API vendors (AWS, Azure, OpenAI, Anthropic) are the silent giants here, benefiting whether enterprises build or buy, as long as they consume compute and tokens.
We are also witnessing a re-intermediation of the consulting industry. With 40% of agentic AI projects predicted to be cancelled, the demand for failure-avoidance services — technical due diligence, architecture assessment, AI governance — is exploding. Deloitte, McKinsey, and Accenture are not being disintermediated; they are being re-positioned as the safety net for an over-eager market.
As I watch this unfold from my Miami perch, analyzing liquidity flows and CBDC architectures, I am struck by a pattern: every technological revolution overpromises and under-delivers, then eventually finds its equilibrium. The 32% build-vs-buy shift is not a verdict on agentic coding's readiness; it is a bet on its trajectory. And in that bet, there is a quiet truth — a transaction is just a promise frozen in time, and the most valuable promises are those backed by systems that can keep them. The enterprises that succeed will be those that treat AI coding not as a sprint to replace developers, but as a marathon to rebuild the very concept of software ownership.
The question that lingers as 2027 approaches: will the 40% of cancelled projects be remembered as failures, or as the tuition fee for an entire generation of organizations learning the discipline of building with AI? If history is any guide, the answer will emerge not from the headlines, but from the quiet balance sheets of those who learned to treat operational costs as design constraints and failure as data.
In the end, this is not a story about code. It is a story about trust — in our tools, in our teams, and in our ability to navigate the beautiful, terrifying chaos of creation.