When Software Becomes Strategy

Build-versus-buy has cycled with every era of computing. Mainframes were custom. Client-server standardized. The early web was custom again. SaaS standardized again. The cycle was so reliable it became an assumption: "build" is a phase, "buy" is the steady state.

Building has been getting cheaper for decades. Each wave produced the same prediction, and each time SaaS won anyway, because distribution and ecosystem advantages outweighed cheaper construction.

AI coding tools changed the arithmetic differently. Previous waves reduced the cost of a first version. These tools compress the full cycle: what took a team of ten working for six months now takes two engineers working for two weeks. A different kind of cost reduction than cheaper hosting or free libraries, because it changes which projects are worth attempting at all.

The standard counterargument is maintenance. Fair enough. But as reasoning capabilities improve, code review, regression testing, and patching increasingly become tasks that intelligence handles. The harder objection is production quality: can AI-assisted teams ship systems that hold up under real load? In our work at AgentField, small teams have been shipping production infrastructure at a velocity that would have required three or four times the headcount two years ago. We hear similar numbers from engineering leaders across the industry. The output still needs experienced judgment on architecture and edge cases, but the gap between prototype and production-grade is narrowing quarter by quarter.

The interesting part, though, is less about cost than about what companies need to encode. SaaS worked because intelligence lived in people, outside software. Two banks could share a CRM because the CRM held records, not reasoning. Their advantage was their traders, their risk committees, the executive who knew which counterparty to trust in a volatile market. The software was commodity plumbing underneath human judgment. Sharing it gave up nothing.

Judgment Enters the Code

When an AI system at a bank stops routing support tickets and starts evaluating whether a specific counterparty exposure is acceptable given the firm's current portfolio, its stated risk appetite, and this morning's market conditions, the system has crossed a line. It has stopped automating a workflow and started exercising judgment that previously lived in a senior trader's head.

This migration is worth paying attention to. Intelligence is moving from human heads into the reasoning layer of the software. The software carries judgment now, not just data.

Two competing banks running the same CRM was safe. The CRM held records. Two competing banks running the same AI risk system is a different proposition entirely. If the system encodes how the firm weighs uncertainty and resolves the tension between growth and safety, sharing it is closer to sharing a senior leadership team than sharing office furniture.

Software used to be furniture. Everyone had the same desks because desks hold no competitive advantage. Software is becoming the playbook. Nobody buys their competitor's playbook.

A large share of current enterprise AI still operates at the furniture layer: ticket routing, document classification, customer triage. That work can be productized and bought. The next wave of AI SaaS companies is already being assembled around it. But the category of software that carries organizational judgment is growing, and it follows different rules entirely.

Laws That Turned Out to Be Weather

The strategy frameworks taught in business schools were designed around constraints that felt permanent. Talent is scarce and geographically concentrated. Management has a finite span of control. Decision quality degrades as organizations grow because judgment dilutes through layers of delegation. Entire industries organized around these assumptions: outsourcing, offshoring, management consulting, organizational design, corporate training. All responses to the same underlying reality that human intelligence is expensive, slow to develop, and geographically stuck.

Those constraints are becoming variables. LLM inference costs have dropped roughly 90% in the past two years, and reasoning benchmarks now match median human performance on an expanding set of professional tasks.

A few of the properties of intelligence that have changed:

Commoditized. Reasoning capability is available on demand, through an API, at marginal cost approaching zero.

Scale-independent. One agent or ten thousand. The quality of the hundredth decision matches the first.

Geography-independent. An agent in Mumbai reasons as capably as one in Manhattan.

Tireless. No burnout, no attrition, no ramp-up time for new hires. Judgment available at 3 AM on a Sunday.

Every strategic assumption built on the opposite of these properties is now open to rethinking. Most companies are responding by automating the strategy they have. The more consequential question is what strategy would look like if designed from scratch for these economics.

That question encounters real resistance. It asks organizations to distinguish between what they are and what they are merely doing. Many processes feel core when they are inherited habits from an era of scarce intelligence. The way a company prices, routes, underwrites, or allocates may feel foundational. Some of it is. Some of it is habit dressed as principle.

The reasoning that emerges from this rethinking lives in the software. It becomes the software. And it is specific to the organization in a way that no previous generation of enterprise technology has been. It encodes how this particular company weighs risk, where it sees opportunity, what tradeoffs it is willing to accept. The organizational DNA of its future competitive position, written in code. No vendor sells it, because it didn't exist before the organization examined itself closely enough to produce it.

At the automation layer, buying remains rational. At the strategy layer, buying is incoherent. You cannot purchase your own reinvention.

The Bottleneck Nobody Prepared For

The constraint doesn't vanish when engineering is cheap. It migrates somewhere most organizations have never looked: the capacity for honest self-examination. Which parts of the business are genuinely core? Which are inherited constraints posing as strategy? These are questions of organizational identity, and most companies have never had to answer them because the cost of building made the questions academic.

The cost of building no longer makes them academic.

JPMorgan Chase spends eighteen billion dollars a year on technology and employs forty-three thousand software engineers. Jamie Dimon has said, repeatedly, that he doesn't mind building anything in-house. That used to be an outlier, a posture available only to companies with enormous resources. When engineering itself is cheap, the posture is available to everyone. What remains scarce is the willingness to look honestly at what your organization actually is versus what it has been doing out of habit and vendor dependency.

Large organizations are not set up for this kind of introspection. Decades of vendor-driven IT strategy, procurement processes optimized for purchasing, and governance structures built around evaluating external solutions all create gravitational pull toward buying. That gravity is real, and it will slow the shift. But it won't stop it, because the companies that do this work will operate at a structural advantage that buying better tools cannot replicate.

The question worth asking has moved past build or buy. It is whether you are automating the strategy you have, or engineering the one that comes next.

When software starts carrying judgment, the infrastructure underneath it changes. We've been writing about what that looks like: from why every serious backend will need a reasoning layer, to what breaks when AI makes a trillion decisions, to the accountability tooling autonomous systems require. That infrastructure is what we're building at AgentField.