Dumb pipes

Long before Yali and I started Snowplow, I worked at a small London consultancy that served two very large mobile telcos (one red, one orange) as clients. It was prior to the launch of the iPhone, but the changing environment was already weighing heavily on the telcos' strategists: most of our projects were around helping the MNOs (mobile network operators) avoid becoming the much-feared 'dumb pipe'.
‍
What did we mean by 'dumb pipe'? The telcos were worried that all of the differentiated user experience—all of the perceived value—would migrate to the cell phone manufacturer, or to the phone's operating system vendor; in this world, the MNO would be relegated to a commoditized voice and data 'pipe' that could be swapped out for a cheaper provider. The first public reference to 'dumb pipes' is in a Wired article from 2008, The Untold Story: How the iPhone Blew Up the Wireless Industry.
‍

We all know how this story ended—at the consultancy, our various ideas and projects couldn't reverse this fate, though not for want of trying. To the victor belong the spoils: as a mobile app developer today, you pay your 30% commission to Apple for all iPhones, and to Google for all phones running Android.

Simply put, Apple and Google own the strategic consumer experience wedge on mobile where the profit pools. Of course, each cell phone user still has some level of relationship with their MNO, but today very little of the on-device experience is owned or mediated by the telco itself.

As they say, history doesn't repeat, but it often rhymes.

‍Today there is a similar situation emerging for the multi-billion dollar SaaS industry, where developments in the AI agentic space threaten to turn these SaaS vendors into 'dumb tools'.

Agentic tools and MCP

Humans have been using tools since the dawn of mankind– as evidenced by the Lomekwi 3 archaeological site in Kenya, dating to some 3.3M years ago. Today hand-operated tools have standard sizes and shapes that reflect the two forms of gripping with the hand: the "power grip" and the "precision grip" (coined by John Russell Napier in 1956, popularized in his book Hands).

Now, as AI agents emerge and proliferate, a strong consensus has emerged that these AI agents also need to be able to operate tools. Of course, these agentic tools will be more of the digital variety than the stone-battering type: agents need to be able to operate in a rich ‘action space’, from searching the web and booking flights, to updating the company intranet and filing purchase orders.

AI engineers building these agents ran into a problem: there was no legible, predictable interface for the diverse array of SaaS, data sources and digital services that these agents would want to operate as tools. To address this, Anthropic designed and launched something called Model Context Protocol (MCP) in November 2024:

‍

MCP is an open protocol that standardizes how applications provide context to LLMs. Think of MCP like a USB-C port for AI applications. Just as USB-C provides a standardized way to connect your devices to various peripherals and accessories, MCP provides a standardized way to connect AI models to different data sources and tools.

‍

MCP’s origin story, from Anthropic engineers David Soria Parra and Justin Spahr-Summers, is fascinating – if you have time, check out the Latent Space podcast episode with The Creators of Model Context Protocol.

MCP is what Steven Sinofsky has called the “classic middleware playbook”. In that March 28 article, he asked “Will It Win?”. But with OpenAI embracing it that same month, plus incredible adoption across the software ecosystem, it’s clear that MCP has won:

‍

‍

To quickly see an open standard emerge is great, and certainly better than the alternative of seeing standards competition, thrashing and fragmentation. But standards are not an unalloyed good for everybody in the ecosystem…

‍

Moat Corrosion Protocol

Every night in San Francisco, the Day for Night artwork pulses multicolor psychedelic patterns from the crown of Salesforce Tower, 61 floors up. The market cap for the 10 largest US-listed SaaS companies is $1.3 trillion (source). SaaS will not go quietly into the night.

MCP represents an age-old tech play: you commoditize your complements to make it as easy and cheap as possible for customers to adopt your own offering. It's why so many tech businesses in the same value chain are mutual "frenemies": your partners make your software more useful, but you don't want them capturing too much of the value; if they get uppity, you encourage your customers to swap out to a cheaper substitute, like AMD for Intel back in the 90s.

Various industry observers are now calling out this risk to tech companies - from The Information (OpenAI’s ‘Agents’ Pose Risks to DoorDash, Other Consumer Apps) to Benedict Evans in his last March newsletter, and our own Yali Sassoon (Will Your Brand's AI Agents or Someone Else's Serve Your Customers?). But the point was best made by Twitter pundit signüll:

‍

‍

Like the telco 'dumb pipes' before them, MCP risks consumer apps and SaaS vendors becoming 'dumb tools'. All of the differentiated value will accrue to the provider of the agentic system; if your software or service is obscured and abstracted behind a standardized MCP interface, then you are replaceable over time by a cheaper or better substitute. Tech companies didn't get the margins they command by embracing fungibility; the lock-in is the moat which ultimately drives the margin. MCP threatens that.

Let’s take the example of an AI agent that needs to send a text message to a customer. If all the popular SMS service providers provide APIs, and potentially even their own MCP server (see Twilio’s here), then the AI agent can easily switch out between them:

‍

‍

‍

As a SaaS vendor, if you continue to offer all capabilities solely through MCPable APIs, you will be commoditized by somebody else’s agent as a ‘dumb tool’. So what’s the solution?

‍

Let one thousand agents bloom

The solution for tech companies is simple (but not easy): elevate the core offering from UI plus API to a proprietary agentic experience.

SaaS vendors will shift their ‘tollbooth’ up the stack to proprietary agentic experiences that they own and operate themselves. This isn’t a purely defensive move: these SaaS agents will be genuinely novel and powerful, enabling emergent behaviors as these agents dynamically communicate with each other to exchange data and tasks.

If you are still skeptical – think of this future as embedding intelligence inside the API calls between different software applications. Shifting from a world of formal software integration by software engineers, to a world where the apps dynamically communicate to form ad hoc, just-in-time integrations to accomplish specific goals.

My favorite example of this trend right now is Snowflake. Snowflake is super-focused on winning adoption of a new offering called Cortex Agents, an agentic capability which allows a human (or another agent) to query across structured and unstructured data:

‍

They plan tasks, use tools to execute these tasks, and generate responses. Agents use Cortex Analyst (structured) and Cortex Search (unstructured) as tools, along with LLMs, to analyze data

‍

In the data ecosystem today, there are major pressures towards commoditization through open-source data infrastructure projects like Apache Iceberg, DuckDB, Apache Arrow and Delta Lake. To resist this commoditization, vendors like Snowflake must move up the stack, away from MCPable common tooling, and provide differentiated new experiences like Cortex Agents.

These agentic experiences will be proprietary to each vendor, dynamic, interactive and stochastic. They will be, simply put, impossible to commoditize. But for this to work, these agents have to be able to inter-operate – there has to be a lingua franca, an Esperanto, that all these agents can speak with each other.
‍

Enter Agent2Agent

On 9 April, the first day of Google Cloud Next, Google announced Agent2Agent Protocol (A2A), a new standard protocol to enable:

Dynamic, multimodal communication between different agents without sharing memory, resources, and tools

‍

Crucially, A2A is designed to cross organizational or technical boundaries, which means that an enterprise can write its own agents (using LangGraph, n8n, Confluent or similar) and these agents can directly talk to third-party agents (from Salesforce, Datadog, ServiceNow or similar):

‍

‍

For me the most striking thing was the sheer number of endorsements as part of the announcement: I counted 35 ISV endorsements, from Ask-AI to Weights & Biases; and a further 8 SI and services partners. And this is not just box-ticking – already vendors are brainstorming ways to extend A2A, for example Sean Falconer from Confluent exploring Apache Kafka for loose coupling of A2A agents.

‍At Snowplow we have spent many years helping two software categories (digital analytics and Customer Data Platform) to move to much more composable approaches atop the enterprise data warehouse. What is so exciting about Agent2Agent is the potential for composability to break out of individual software categories and become an emergent property across all enterprise SaaS.

Of course – it is still early, and building an open-standard with such a weight of expectation from so many SaaS companies is fraught with challenges and risks; there will also be plenty of scrutiny on Google, who has played the lucrative role of intermediary in multiple prior markets.
‍

Conclusion

The rise of AI agents represents what Andy Grove would call a ‘strategic inflection point’ for almost all SaaS companies. As a tech vendor you must preserve your own differentiated and proprietary software moat, but MCP threatens to turn your SaaS into the ‘dumb tool’ of someone else’s agent.

The response is clear: SaaS companies will move up the stack, building their own agentic experiences which create a powerful new layer of differentiation. This isn’t a cynical move: these new AI agents should allow for genuinely novel workloads and interactions which drive a lot of value for enterprises. And Agent2Agent Protocol will be the glue that connects all of these agents together.

Things are moving incredibly fast, from the open-source adoption of MCP to the breadth and depth of vendor support for Agent2Agent. It’s clear that developing differentiated and proprietary agents is a strategic imperative across SaaS boardrooms right now – let’s see where it takes us.

‍