Is it time for MCP First?

Back in 2002, Jeff Bezos published the now legendary "API Mandate" memo. The true source of this may have been lost to the ether, but it appears to have been shared ten years later by a Google engineer, and his post is preserved here on GitHub.

Here's the gist of it:

• All teams will henceforth expose their data and functionality through service interfaces.

• Teams must communicate with each other through these interfaces.

• There will be no other form of interprocess communication allowed: no direct linking, no direct reads of another team's datastore, no shared-memory model, no back-doors whatsoever. The only communication allowed is via service interface calls over the network.

• It doesn’t matter what technology they use. HTTP, Corba, Pubsub, custom protocols — doesn’t matter.

• All service interfaces, without exception, must be designed from the ground up to be externalization. That is to say, the team must plan and design to be able to expose the interface to developers in the outside world. No exceptions.

• Anyone who doesn’t do this will be fired.

Bezos was clearly early to the microservices game — although we wouldn't have called it that yet - it was evolved thinking at a time when SOA was the buzzword du jour.

So, why did Bezos publish such a mandate?

• Customer-centricity: Encouraging teams to treat their colleagues as external customers increases their readiness both internally and externally.

• Agility and decoupling: This mandate allowed teams to evolve independently without cross-functional dependencies.

• Scalability: Modular services made rapid expansion simpler.

The API mandate was transformative for Amazon, with benefits that rippled throughout the organisation and set the stage for future success. At its core, the mandate forced teams to think differently about how they built and exposed their services. By requiring all communication to happen through well-defined APIs, teams naturally created more modular, maintainable systems while gaining true ownership of their domains. This external-first mindset opened up major business opportunities, as teams began recognising the commercial potential of their internal services - like AWS, Amazon Fulfilment, and Amazon Marketplace.

Have we now reached a point with AI where, like Bezos' "API First" mandate, we should be thinking "MCP First"?

MCP (Model Context Protocol) is an open standard initiated by Anthropic. It gives you a standard way to provide context to models and services. This lets you break big, complex problems into smaller parts and then bring them back together again. Instead of building one monolithic system, you compose a network of specialised services - each focused on its own domain, exposing what it knows, and nothing more. You can read an introduction in my previous post.

Every application and service should now be designed with autonomous agent capabilities in mind from the very start. Just as API-first thinking transformed how we build and integrate services, MCP-first design ensures our systems are ready to leverage agents, integrate with language models, and adapt to rapid advances in autonomy and orchestration. This approach also creates opportunities for agent-powered features and automation that can dramatically improve user experience and operational efficiency. It may open doors to opportunities your business hasn’t even imagined yet.

So if Jeff Bezos wrote an MCP First memo today, what would it look like?

1. Every team must expose their data, functionality, and decision logic via MCP-compatible interfaces—no exceptions.

2. All team-to-team communication must happen through these MCP interfaces. No shortcuts, no private backchannels, no exceptions.

3. MCP interfaces must be designed from day one for external use - assume they’ll be accessed by customers or partners in the near future.

4. MCP is now the standard protocol for all integrations, both internal and external. Every new service or feature must be MCP-native from the outset.

Why would we do this?

1. Customer-centricity: Every interaction is hyper-focused on customer context, providing personalised, intelligent experiences through autonomous agents.

2. Agent-centricity: Enabling systems designed from day one to collaborate with autonomous agents as first-class citizens.

3. Context-driven communication: Shifting from static APIs to dynamic MCP servers that understand the customer’s context deeply, enabling richer, more intelligent service interactions.

As "API First" helped Amazon move beyond being "just" an online retailer and positioned them to dominate cloud infrastructure, "MCP First" could help you unlock the next wave of intelligent, adaptive products. Of course, there are no silver bullets: in the same way microservices can be architectural overkill for a two-person startup, MCP could be overkill unless you are ready and able to exploit agent-driven capabilities to their maximum.

But if you sit still, your competitors manoeuvre around you. What's your strategy to be ahead on agent adoption? Feel free to dm me to discuss.