This is the third in a five-part series on the software industry in the age of AI. 

In the early days of enterprise software (1980s–early 2000s), vendors raced to offer sprawling, feature-rich solutions that locked customers into bespoke, hard-to-maintain systems. It took nearly a decade and the rise of software as a service for the industry to unlearn that behavior and embrace simplicity, interoperability, and cloud-based agility.

Now, with the rise of AI agents, history risks repeating itself. Some software makers are pursuing their AI ambitions by piling on features, embedding multi-agent frameworks, and promising one-stop solutions.

That’s a mistake. AI agents have unleashed more flexible ways of programming that make integration easier. Developers should be offering building blocks to their clients, not complete solutions. As this market matures, success will derive not from building the most, but rather enabling the most.

Do fewer things—but better

Why is this hard? It requires a change in approach and mindset. Software product designs have long aimed to deliver the most comprehensive solution at the best value. Suddenly, customers see what AI agents can do, and they no longer want rigid toolsets. They want modular platforms they can shape to suit their needs.

To meet those customer needs, companies should prioritize configuration over customization. When customers can adapt a product through supported settings and extensions, rather than rewriting core logic, it’s far easier to upgrade as the platform evolves. The payoff is mutual: Vendors protect scalability and upgrade speed, while customers stay current and benefit from continuous innovation instead of getting stuck with brittle, one-off builds.

The new priority should be to expose your software’s capabilities in machine-readable, well-documented, and composable forms. Think clear APIs, modular services, and abstracted logic layers. Customers and developers will use your building blocks to construct experiences that fit their needs. The less opinionated your workflow is, the more adaptable your product becomes.

Modularize the architecture

Most organizations have already decoupled the front end and data layer from core business logic into modular services. Those that haven’t should do so, to eliminate that technical debt first. But even modularized architecture isn’t ready by default. Here’s what must change when agents need to interact with each layer.

• User interface (UI). Decouple UI elements so they can be reached by agents via API. Treat the user experience as a semantic structure that carries intent and meaning, rather than as a visual layout. If you don’t, agents will resort to scraping your web pages and automating clicks, generating excessive, brittle requests that strain your infrastructure and deliver a terrible experience.
• Operating logic. Separate deterministic logic (rules, calculations, validations) from probabilistic decisions that agents can own. Deterministic operations should be callable via APIs so agents can execute them reliably. Probabilistic judgment calls (prioritization, recommendation, triage) are where agents add the most value and should be clearly bounded so failures are contained.
• Data layer. Design data APIs for how an agent will access them, not how your front end does so today. Most companies have data APIs, but simply exposing them to agents could be dangerous, allowing excess data exfiltration. You need agent-specific, role-based access control; rate limits; and auditing.

This architectural clarity reduces internal complexity, and it allows others to engage with your product in entirely new ways, beyond the standard UI. Whether it’s a customer building their own agent, or a partner integrating deeply into your workflows, modularization makes it possible without massive rewrites or integration debt.

Don’t wait for perfection

A comprehensive AI platform is still years away. Expecting agents from every vendor to seamlessly work together is an attractive vision, but not a realistic three-year plan.

In the meantime, software executives should start moving toward a modularized architecture now. First, expose what you already have. If an existing API would be useful to an agent as-is, open it up now. This is a low-effort move that will tell you immediately what agents want to do with your product.

Next, build the critical new APIs. Identify the most important read and write actions your agents will need and develop those APIs next. Make them available to customers too.

Third, learn and operationalize. As you observe how these APIs are actually used, you’ll develop the muscles for protecting, metering, and role-assigning agent access. That learning will give you a far clearer view of how to continue modularizing.

Successful tech leaders set a clear direction with just enough guardrails to prevent chaos, while empowering their teams to make rapid progress.

AI may be the most powerful tailwind software has seen in decades. But to capture it, software companies should stop trying to do everything perfectly. By starting with modularization and an architectural ambition that can evolve over time, software companies can make sure they’re not just ready for an AI future—they’re essential to it.