The Agentic Shift From APIs to Experiences

Why the Agentic Shift Matters Now

When I outlined the Agentic Blueprint technical white paper, I had a few core ideas in mind. Everyone expected a point of view on the emergence of AI Agents—but I know who you are and what you actually need to hear about.

• Tech platform teams. For the APIs you’re shipping today, start preparing them to be AI-ready for LLM-powered agents.
• Application architects. Learn what the Model Context Protocol (MCP) enables, and why exposing APIs as tools via MCP servers changes integration and reuse.
• Product managers. Re-think current SaaS offerings as future agentic applications composed of semi-autonomous AI experiences.
• UX researchers and designers. Prepare for a shift from “users click through screen flows” to “users state intent and supervise outcomes.”

Intentionally designed, human-centered usability is already table stakes. What’s changing is the balance between trust, control, transparency, and recovery in systems that increasingly do the work on a user’s behalf.

In other words: agentic applications.

We are well past the idea that AI is a nice-to-have. Software is evolving to deeply incorporate understanding, reasoning, and action—and that evolution has consequences for how we design, build, and operate systems.

The API Layer Is Where the Shift Begins

The first concrete impact of agentic systems shows up at the API layer.

For the APIs you’re shipping today, start preparing them to be usable by LLM-powered agents. That means designing for granularity, semantic clarity, reliability, and cost awareness.

It also means delivering intentionally written OpenAPI specifications, with clear descriptions and concrete examples that show how your REST/JSON endpoints are meant to be used. APIs that rely on human intuition, implicit assumptions, or monolithic payloads introduce friction when agents—not people—are the primary consumer.

As agentic systems mature, API shape increasingly determines what’s even possible upstream.

From Static Integration to Dynamic Orchestration

Making APIs usable by agents is only the first step. The next question is how agents discover, select, and coordinate those APIs at runtime.

This is where the Model Context Protocol (MCP) matters. MCP shifts integration from static wiring—typical request/response coding—to dynamic orchestration. When APIs are exposed as tools through MCP servers, agents can reason about capabilities, sequence actions, and execute workflows without hand-coded glue logic.

Architectural judgment becomes critical here: knowing when to expose your own APIs via MCP, and when it’s smarter to consume MCP servers from trusted partners rather than rebuilding domain expertise you don’t own.

Product Judgment in an Agentic World

Once orchestration moves from code to reasoning systems, product questions surface quickly.

This is not about sprinkling AI features into existing SaaS products. It’s about deciding which offerings should evolve into agentic applications.

Agentic products are collections of semi-autonomous experiences that execute workflows on a user’s behalf. Not every feature belongs there, and not every workflow benefits from autonomy.

Product judgment—what many would call “taste”—now lives at that boundary: where agent-driven execution creates leverage, and where deterministic, explicit flows still matter.

Designing for Intent, Oversight, and Trust

As products become agentic, user experience design must evolve with them.

UX is shifting from guiding users through screen flows to helping them state intent and supervise outcomes. Interfaces become less about navigation and more about confidence.

That confidence comes from clarity: what the system is doing, why it’s doing it, and when control returns to the human.

Human-centered usability remains essential—but what changes is the balance between trust, control, transparency, and recovery in systems that increasingly behave like capable teammates rather than passive tools.

A Forward-Looking View of Agentic Software

Bringing all of this together leads to a set of practical, forward-looking expectations. These are not sci-fi predictions, but stretch goals grounded in current trajectories.

In the long run, software may become fully autonomous. In the nearer term, systems must earn the right to act.

We are still early enough that most mistakes are educational. That won’t always be true. Over time, the cost shifts from “we tried something and learned” to “we waited too long and now we’re catching up.”