The Real AI Race Isn’t for Better Models. It’s for Pricing Power.


Every Sunday night, someone somewhere is refreshing an LLM leaderboard.

A new model edges out the old one on a coding benchmark. Another claims a fractional improvement in reasoning. Social media fills with grand declarations that everything has changed again.

It usually hasn’t !

We’ve spent the last two years obsessing over who has the smartest model. We should probably spend the next two asking a very different question.

Who still has the ability to charge a premium?

Because pricing power, not model intelligence, is what ultimately determines who builds enduring businesses.

This is the fundamental mistake much of the industry is making right now. AI doesn’t simply make software easier to build. It changes what customers are actually willing to pay for. Those are two very different things.

As AI capabilities become widely available, intelligence itself starts looking less like a premium feature and more like electricity. Useful. Essential. Increasingly expected. But rarely differentiated. That shift has serious consequences for enterprise software.

For decades, software companies competed by building capabilities that were difficult for others to replicate. AI is rapidly lowering that barrier. When many vendors can assemble remarkably similar capabilities from the same handful of frontier models, differentiation disappears faster than most pricing models can adapt.

The real competition isn’t for better models. It’s for pricing power.

Value Creation vs. Value Capture

Enterprise software has historically been an extraordinary business.

Building great software required years of engineering investment. Once built, however, every additional customer cost almost nothing to serve. High gross margins followed naturally because the difficult part was creating the product, not delivering it.

AI changes both sides of that equation. Generating software is becoming dramatically cheaper, and capabilities that once took years to build are becoming accessible to far smaller teams.

The application layer absolutely matters. Pretending otherwise is a mistake. Workflow design, user experience, deep integrations, trust, governance, and domain expertise all create immense value. But the question isn’t whether they create value. The question is whether they create sustainable pricing power. Those are not the same thing.

When the underlying intelligence for these tools increasingly comes from the same small set of foundation models, capability itself converges far faster than previous generations of enterprise software. If a customer can achieve a similar outcome from five different vendors, the differentiation shifts away from the capability itself and toward the operational advantages surrounding it. Value is created, but the ability to charge a premium for it disappears.

When Labor Becomes Software

This compression creates a dangerous economic dynamic for vendors trying to shift from selling seat licenses to selling outcome-based “digital workers.”

The pitch sounds compelling: We aren’t selling software anymore; we are replacing human labor. If a human agent costs $30 an hour, and our AI agent costs $5 an hour, we can command massive pricing power.

That strategy works perfectly, right up until three other AI agent startups launch in the same vertical.

As labor is converted into software, it becomes increasingly subject to software commoditization forces. If one vendor charges $5 an hour, a competitor operating a more efficient execution loop will offer it for $2. The value-based pricing model rapidly degrades into a cost-plus race to the bottom. The irony is that replacing human labor with software does not necessarily create a software monopoly. It may simply create a larger and more competitive software market.

The better these systems become at performing human tasks, the more they are exposed to the same economic forces that affect human labor markets: competition, substitution, and price pressure.

Meanwhile, enterprise customers expect more. They expect longer context windows, autonomous agents, and reasoning instead of simple retrieval. They expect voice, memory, automation, orchestration, and continuous improvement.

Yet every one of those improvements increases computational work behind the scenes.

So vendors find themselves caught between two opposing forces. Customers expect prices to fall because “AI is getting cheaper.” Meanwhile, the cost of reliably delivering enterprise-grade AI often rises as workflows become more sophisticated.

That’s not simply margin compression. It’s the steady erosion of pricing power.

The Investor Paradox

This dynamic exposes a fundamental disconnect in the markets today. Investors often assume that AI will expand software margins because more work becomes automated. The exact opposite may happen in many categories.

Automation increases the supply of software capabilities faster than enterprise demand can absorb them. The market has historically rewarded companies that create scarce capabilities. AI’s challenge is that it may create abundant capabilities faster than businesses can absorb them. When supply expands rapidly, differentiation becomes harder and pricing power weakens.

AI may create trillions of dollars in macroeconomic value. It may also make it incredibly difficult for individual software companies to capture that value.

The Loop Trap, Revisited

As I argued in The Loop Trap, enterprise AI isn’t expensive because of tokens. It’s expensive because of loops.

Retries. Approvals. Validation. Tool calls. Human intervention. Recovery paths. You know the drill! Those loops don’t disappear when models improve. If anything, customers demand more of them.

Inevitably, some legacy software incumbents will argue that enterprise inertia will protect them from this reality. They believe that because they are already integrated into the client’s infrastructure, their pricing remains safe.

But workflow lock-in is a defensive moat, not an offensive one. I am not sure how many amongst us realize this!

Workflow lock-in protects retention. It does not automatically protect expansion. The moment a CIO realizes that an automated capability has become a cheap commodity utility, the psychological willingness to pay a high SaaS premium vanishes. During the next renewal cycle, procurement will aggressively squeeze that line item down, using the threat of cheaper alternatives as leverage.

The incumbent keeps the customer, but loses the margin.

The companies that understand this will spend less time chasing benchmark improvements and more time reducing execution cost. Because every dollar saved inside the execution loop is effectively recovered pricing power.

So Who Wins?

The winners won’t necessarily have the smartest models. As I argued in Systems Over Scale, the true operational gains don’t come from a smarter standalone model; they come from better routing, tighter validation loops, and superior system design.

The winners will have advantages that competitors can’t download through an API.

Distribution. Deep workflow integration. Proprietary operational data. Customer trust. Efficient architectures. Low customer acquisition costs. Operational discipline. Those are the things that actually matter – the basics of a good business that the world seems to have forgotten about in the last two years !

They aren’t glamorous advantages, but they are incredibly difficult to copy. If a company possesses none of them, it’s probably not building a durable software business. It’s temporarily renting intelligence from someone else’s foundation model.

Where Value Actually Moves

Value rarely disappears during technological change. It migrates.

As models commoditize, value moves away from the models. As coding becomes easier, value moves away from writing code. As intelligence becomes abundant, value moves toward everything required to make that intelligence dependable inside an enterprise.

Governance. Integration. Security. Observability. Operational efficiency. Business execution.

The obvious narrative over the last two years was that the application layer would capture the majority of the value. But as those margins begin to trap the unprepared, the Second-Order AI Thesis becomes increasingly compelling. The enduring value remains in building the systems, the integration harnesses, the strict governance, and the actual organizational structures required to make all this abundant intelligence usable, predictable, and secure at scale.

The last two years have been a race to build intelligence. The next decade will be a race to keep charging for it.

As usual, these are strictly my personal views.

The Loop Trap: Why Cheap Tokens Don’t Mean Cheap Tasks


In almost every enterprise AI conversation right now, someone eventually says the same thing: “Tokens are basically free.” I understand why people say it. If the expensive part of building with AI was inference, then cheaper tokens should unlock everything. But that assumption hides a bigger problem. The real cost of enterprise AI was never just the tokens. It was the messy human work required to turn a probabilistic answer into something a business is willing to bet on.

I’ve started seeing the same pattern play out in enterprise agent deployments. A team lets an advanced coding agent loose on a sprawling, decades-old monolithic service, targeting a move to a modern microservices architecture. The agent spends hours autonomously iterating on a large pull request, running local test suites, and fixing its own syntax errors. When the run finishes, the compute bill is often the smallest part of the exercise.

The real invoice arrives the next morning. A senior architect inherits a massive PR with thousands of lines of modified code. Because the agent iterated blindly against the compiler simply to get the tests to pass, it introduced architectural debt: it duplicated data structures, bypassed established caching patterns, and broke shared utilities. The architect spends the next day untangling the mess, tracing regressions, and ultimately rejecting the PR. The tokens were cheap, but the task itself was incredibly expensive.

For most of modern computing, the race was about making computation cheaper and faster. Now we are entering a world where the computer can generate changes faster than the organization can safely absorb them. AI isn’t eliminating the enterprise bottleneck. It is reversing the historical economics of software. Computation is becoming the easy part, and human coordination is becoming the scarce resource.

The uncomfortable realization is that we spent the last decade trying to remove humans from software delivery, only to discover that humans were not the bottleneck we thought they were. They were the control system. When you treat intelligence as an effectively unlimited resource, the operational friction doesn’t disappear. It simply migrates up the stack. We’ve spent years assuming that if we could just automate the code generation, the governance would take care of itself. It just won’t.

The irony is that the first problems appear exactly where we expected the magic to happen: inside the loops themselves. We assume this cycle is free because the tokens are cheap. But errors in these systems compound. The next decision is built entirely on the assumptions created by the previous one. If an agent makes the wrong assumption early, the next several iterations can become an expensive exercise in fixing the consequences of that original mistake. You aren’t scaling capability. You are spending more compute and latency cleaning up mistakes the system created for itself.

The raw economics here are deeply deceptive. The system doesn’t eliminate cost; it simply transfers it from GPUs to people. The model finishes its run in a few hours, but the humans inherit the uncertainty. They now have to reconstruct the reasoning, validate the assumptions, and decide whether the output is safe to ship. Ultimately, the bottleneck has moved from creation to trust.

If you push this architecture to its logical endpoint, you end up with agents optimizing other agents, adjusting prompts, retrieval strategies, and evaluation criteria overnight. The assumption is that another layer of AI can evaluate and improve the first layer. But enterprise software rarely has a perfect definition of success. The danger is that the system starts optimizing what it can measure instead of what the business actually values. It learns how to pass the tests, not necessarily how to preserve the architecture. This is the enterprise version of Goodhart’s Law.

The counter-argument sounds compelling: run enough experiments, and one breakthrough will justify all the failures. Platform developers will tell you that a mature agent architecture operates in an ephemeral sandbox, meaning unsuccessful runs can simply be deleted without leaving a single line of messy code behind. But enterprise software is not a lottery where losing tickets disappear without cost. Even if the code branch is cleanly deleted, the human time spent defining the task, managing the system, and reviewing the failure logs to understand why it missed the mark is still a massive tax on engineering velocity.

The other defense is that AI will simply review AI, relying on an ensemble of specialized judge models or rigid pipeline checks to audit the output. Proponents argue that if your CI/CD and regression testing suites are robust enough, bad architecture will be caught automatically. This assumes enterprise systems possess perfect, exhaustive test environments that capture subtle structural intent, which is almost never true for a legacy codebase. A system can easily pass every automated integration test while still producing structurally unmaintainable garbage that requires a human to untangle.

Without deterministic verification layers, entire ensembles can become highly confident about the same incorrect conclusion. Many enterprise AI deployments will fail not because the models aren’t intelligent enough, but because leadership is rather blind to the sheer cost of coordinating intelligent systems.

If spinning loops doesn’t automatically reduce the total cost of delivery, we have to change how we build. The answer isn’t longer execution loops; it’s a completely different control architecture. We need systems that preserve state instead of repeatedly reconstructing it. We need ways to summarize intent rather than syntax, so humans review decisions instead of thousands of generated lines. And we need deterministic boundaries where software takes over: business rules, financial limits, and termination conditions should not be negotiated by another language model. If a system detects a strict logic circle, such as executing multiple consecutive iterations without a change in environment state, the infrastructure should kill the loop instantly.

The history of computing has largely been about reducing the cost of computation. AI changes the problem. Computation is becoming abundant. Coordination isn’t though. As token prices collapse, coordination costs increasingly become the dominant constraint in many enterprise AI systems. The companies that win this phase won’t be the ones running the biggest models or the longest loops. They’ll be the ones that understand where autonomy helps, and where another loop is simply avoiding a decision.

The irony is that the companies that win enterprise AI may not be the ones that automate the most work. They may be the ones that build the best judgment systems around the work machines can already do.

Cheap intelligence is abundant. Reliable outcomes aren’t. That’s the real loop trap.

The Slowest-Scaling Constraint


One of the easiest mistakes in technology is assuming the most valuable asset is the most visible one.

For the past three years, that asset looked like GPUs.

Every headline tracked NVIDIA shipments. All funding rounds celebrated larger clusters. Every single discussion about AI infrastructure turned into a count of compute.

But visibility is not value !!

AI infrastructure is not a silicon story. It is a capital allocation story. And capital, especially when systems come under stress, follows a consistent rule.

It systematically migrates toward the slowest-scaling constraint in the system.

Not the most exciting technology. Not the biggest market. Not the highest margins. The constraint !

What matters is not where innovation is happening. What matters is where scaling is breaking.

And this is the inversion most people miss.

Capital does not reward what is best. It rewards what is bottlenecked. Because in large systems under pressure, bottlenecks determine throughput. And throughput determines value creation.

The Pattern Beneath Industrial Cycles

This is not unique to AI. It is a recurring structure in every major industrial buildout.

The details change. The constraint does not.

In oil, the early constraint was drilling capacity. Capital rushed into extraction. But once production scaled, the bottleneck shifted downstream into pipelines, refineries, and export terminals. The constraint was never the well. It was the ability to move molecules.

In railroads, the focus was locomotives. But value accumulated in rights of way, corridors, terminals, and bridges. Trains were replicable. Geography was not.

In the internet, early scarcity sat in compute. Then bandwidth. Then fiber and backbone infrastructure. Eventually the constraint shifted again to data centers and interconnect density.

In smartphones, it was not demand or design. It was advanced semiconductor manufacturing, concentrated in a small number of foundries like TSMC.

The pattern is consistent. Capital does not stay where it enters. It moves to what cannot scale fast enough.

The Infrastructure Velocity Gap

AI makes this pattern visible because the system mismatch is extreme.

Software moves in weeks. Silicon moves in multi-year cycles. Physical infrastructure moves in decades – Utility planning, transmission buildouts, substations, permitting, interconnection queues. These layers do not move together. They operate on different orders of magnitude.

When demand accelerates, capital does not flow evenly. It is pulled toward the slowest-moving constraint in the stack.

For a time, that constraint was GPUs.That phase was real. Compute scarcity defined the first wave of AI scaling. But compute did what compute always does in a supply response cycle. It scaled faster than the rest of the system.

Now the constraint has shifted.

It is energy !

Not because compute is less important. But because compute is no longer the slowest-moving part of the system. This is why the conversation is shifting from GPU counts to contracted gigawatts. Because power is not just another input. It is the gating function.

If you control long-duration power, you can acquire compute. If you do not, GPUs are just stranded inventory.

This is already showing up in the system as stranded compute. Hardware is arriving faster than it can be activated. The constraint is no longer procurement. It is activation.

The Imbalance Loop

Capital does not identify constraints cleanly. It discovers them through overshoot.

It floods into a visible bottleneck. Supply catches up. Scarcity disappears. Returns compress and then capital moves !

Find constraint. Over-invest. Normalize into abundance. Move on. This is not efficient nor coordinated. But it is consistent. And it explains why constraints appear to move over time, even though they are layered inside the same system.

The system does not shift suddenly. It reweights where scarcity sits.

Two Structural Distortions

The first is whiplash.

Capital rushes into the constraint once it becomes visible. It overshoots. What was scarce becomes abundant in a short window.

We have seen this in telecom fiber during the dot-com cycle, in shipping capacity, in lithium supply chains, and in solar manufacturing.

The second is efficiency shocks.

Technology reduces cost faster than physical systems can adapt.Software becomes more efficient. Models compress and Hardware improves.

But efficiency does not reduce demand. It expands it.

That expansion pushes the constraint downstream into slower parts of the system that cannot scale at software speed. Efficiency does not remove bottlenecks. It relocates them.

The Real Signal

Most investors try to predict the next breakthrough. That is the wrong signal in my opinion.

The more durable signal is simpler : Find the next constraint !

Because every cycle follows the same structure.

Technology expands what is possible. Demand accelerates faster than physical infrastructure can respond. Capital concentrates at the slowest-scaling constraint. That constraint becomes the center of value creation.

Railroads were not about locomotives. Oil was not about drilling. The internet was not about servers. Each system is remembered for the part that could not scale fast enough.

The Enduring Rule

The most visible asset is rarely the most important one.

Systems reveal their constraint under stress – capital follows it. Technology changes. Constraint changes. Inevitably, value always forms at the bottleneck !