How APIs, MCPs, and AdCP fit together and how MadConnect is serving as the foundational layer

By Bob Walczak, MadConnect CEO

This might sound like hyperbole, but the launch of AdCP (Advertising Context Protocol) really is one of those true “pivotal moments” for the ad tech industry.

It’s akin to the formation of the OpenRTB Consortium in November 2010, which attempted to improve communication between demand-side platforms and supply-side platforms for a smoother programmatic system of transactions.

But to understand what the introduction of AdCP means, you need to understand the architecture it sits on top of  and the critical infrastructure layer that underlines it all.

In essence, AdCP represents market validation that connectivity is the bottleneck in advertising automation. What it doesn’t represent is a replacement for the systems we’ve built over decades. Instead, it’s a communication standard that requires a sophisticated execution layer to actually work. That’s where the conversation gets interesting.

The Foundation: APIs Still Run the Industry

Let me be clear about something: APIs are not going away. They are not “tech debt” in the age of AI. They are the foundational interfaces that allow systems to take action. They allow buyers and sellers to create campaigns, pull audiences, flight ads, and report results.

Every advertising platform you use today operates through APIs. That reality isn’t changing. Your DSPs, SSPs, and CDP — every platform in your ad tech alphabet soup— along with ad servers and measurement platforms all have their own APIs with unique schemas, authentication methods, and data formats. When an agent needs to do something in the real world, it has to go through these APIs.

As you can see, then, this is not a mere theoretical concern. To activate a campaign, you need API access. To pull an audience segment from your CDP, you need API access. To report on conversions, you need API access. These are the base components of the stack, and they’re complex, fragmented, and constantly changing.

MadConnect was built to solve this fragmentation problem.

We are the connectivity layer of the ecosystem. We unify and manage APIs across the advertising landscape. Today, we’re supporting use cases around audience activation, measurement, and reporting by automating the build and maintenance of platform-to-platform connectivity.

We are the aggregation point for all of the unique and dedicated APIs the industry runs on. Understanding what leads up to our aggregation point is important. Let me walk you through it.

The Wrapper Layer: MCP (Model Context Protocol)

Model Context Protocol (MCP), launched by AI platform Anthropic in November 2024, provides a way to give AI agents context about what systems can do without requiring them to understand the underlying code.

Think of MCPs as wrappers around APIs. They don’t replace APIs, they augment them. An MCP understands the capabilities of an API (“this system can create audience segments,” “this platform can place guaranteed buys…”) and translates natural language requests into structured API calls.

Similarly, then, when an agent receives a request like “find pumpkin latte enthusiasts in the Northeast over 35,” the MCP translates that intent into the specific API parameters needed to execute that query.

But here’s the critical point: the MCP still needs the API to actually perform the action.

MCP provides context and translation. APIs provide execution and control. You need both.

The Communication Layer: AdCP (Advertising Context Protocol)

Now let’s add another layer. AdCP builds on MCP to create a standardized language specifically for advertising workflows. It’s designed to let AI agents on the buy side and sell side communicate using common terminology. It negotiates guaranteed buys, exchanging availability information, initiating insertion orders.

The initial focus on guaranteed buys is strategic.

These buys are typically the highest-value placements in the industry. They’re also the simplest to start with. They don’t require the complexity of real-time bidding or the nuances of programmatic curation.

Get the big-budget, straightforward stuff right first; then expand to more complex scenarios.

AdCP defines how agents talk to each other: “What inventory is available?” “Here’s my budget and target audience.” “Let’s execute this IO.”

It’s the language of agent communication across the advertising ecosystem.

But AdCP is another layer of communication protocol, one that enhances your MCP by providing uniformity. So, just as with MCP, it is not an execution system. It doesn’t handle the actual placement of campaigns, the delivery of ads, or the retrieval of reporting data. It simply tells agents what to say to each other, not how to make things happen in the platforms themselves.

For that, you still need APIs. And you need someone managing those APIs at scale.

The Missing Piece: The Execution Layer

This is where most people’s understanding breaks down. And it’s where MadConnect becomes most essential.

For AI agents to take real-world action — e,g, initiating a campaign, pulling an audience file, checking inventory availability — they need to connect through existing platform APIs. AdCP can provide the language for agents to communicate their intent. MCPs can provide context about platform capabilities. But neither actually executes the commands.

MadConnect serves as the bridge between the communication layer and the operational reality of the advertising ecosystem. We aggregate, normalize, and maintain connections to all the platforms that matter. When an agent “speaks AdCP” to request an action, that request ultimately flows through our managed API infrastructure to the actual systems that execute it.

Without this execution layer, AdCP is just an elegant language with nowhere to go.

The agent can say, “I want to place a $500K guaranteed buy targeting premium inventory.” But someone still needs to translate that into the specific API calls for the DSP, ensure the audience data flows from the CDP, verify the creative assets are in the ad server, and monitor the campaign delivery.

This is what we mean by “The Intelligent Connectivity Layer.” MadConnect unites APIs (execution) with MCPs (context), making AdCP actionable in the real world. We are the operational backbone that transforms standardized agent communication into actual advertising outcomes.

Why This Validates MadConnect

AdCP’s introduction confirms the market pain point we’ve been solving for years.

Let me be direct about what this means. MadConnect is not competing with AdCP — we are the necessary foundation that makes it function in reality. Just as cloud providers made implementation of open standards like Kubernetes more accessible, MadConnect operationalizes the open standard for advertising automation.

Think about the analogy to earlier industry standards. Earlier, I compared the creation of AdCP to the forming of the OpenRTB Consortium. Here’s why: initially, OpenRTB was brought to the ad tech industry to provide a common language for programmatic bidding. But it still required exchanges, SSPs, and DSPs with sophisticated technology infrastructure to execute those bids.

The standard enabled interoperability; the technology platforms enabled execution.

AdCP follows the same pattern. It provides a common language for agent-to-agent communication while the advertising ecosystem continues to operate on dozens of proprietary platforms, each with their own APIs, data formats, and operational requirements.

And as those systems remain the foundation for decades of investment in functionality, compliance, and business logic, an aggregation layer is necessary to bridge the gaps.

To reach its full potential, AdCP needs a system that understands how to communicate with every major advertising platform, normalize data across incompatible schemas, manage authentication and rate limits, and provide agents with reliable, consistent access to the ecosystem’s functionality.

That’s MadConnect. We are the plumbing that makes the protocol speak.

The Complete Stack

When you put it all together, the hierarchy becomes clear:

• APIs = The foundation. The actual interfaces that control advertising platforms and execute actions.
• AdCP = The communication layer. Standardized language for agent-to-agent dialogue in advertising workflows.
• MCP = The wrapper layer. Context and translation that helps agents understand platform capabilities.
• MadConnect = The execution layer. Unified API management that aggregates, normalizes, and maintains connectivity across the ecosystem.

Each layer builds on the one below it. You can’t skip the foundation and expect the structure to stand.

The industry’s rush to embrace AI agents is understandable—the potential for automation and efficiency is enormous. But the companies that will succeed are the ones that understand the entire stack and build on solid infrastructure.

If AdCP is the open language of the future, MadConnect is the infrastructure that makes it speak and amplifies its voice. And in an industry built on APIs, that infrastructure isn’t optional — it’s essential.