MCP, A2A, marketing AI agents, agentic AI architecture, marketing automation

How to Build a Simple Marketing-Agent Architecture With MCP + A2A

Short answer: Use MCP when an AI agent needs access to tools, APIs or business data. Use A2A when one independent AI agent needs to discover, communicate with or delegate work to another agent. A practical marketing system can use both: a marketing agent accesses analytics through MCP, delegates lead qualification to a sales agent through A2A, and the sales agent uses its own MCP connection to the CRM.

That sounds technical, but the business idea is simple:

MCP gives an agent tools. A2A gives an agent coworkers.

This tutorial builds a simple marketing example around one business question:

Which marketing leads deserve sales follow-up, and why?

The goal is not to build a giant autonomous marketing department. It is to understand the architecture well enough to know where MCP belongs, where A2A belongs, and where ordinary automation is still the better choice.

What Is MCP?

The Model Context Protocol (MCP) standardizes how AI applications connect with external tools, APIs and resources.

Think about a marketing agent that needs information from analytics, a database, a content library or another business system. Instead of building a completely different integration pattern for every agent, MCP provides a standard interface through which compatible clients can discover and use available capabilities.

In our example, the marketing agent might have MCP-accessible tools for:

• retrieving campaign performance
• querying website analytics
• reading approved marketing assets
• looking up landing-page information
• retrieving lead-source data

The important point is that these are tools and resources, not independent coworkers.

What Is A2A?

Agent2Agent Protocol (A2A) is an open standard for communication and collaboration between independent AI agents.

A2A focuses on a different problem. Instead of asking, “How does my agent call this tool?”, it asks, “How can my agent work with another agent?”

The official A2A specification describes capabilities including agent discovery, task management, interaction negotiation and secure information exchange without requiring one agent to expose its private memory, internal tools or proprietary implementation to another.

A2A v1.0 is the first stable, production-ready release. The project was originally developed by Google and is now under Linux Foundation governance, with a technical steering committee representing major technology companies.

MCP vs A2A: The Simple Difference

Question	MCP	A2A
What does it connect?	Agent to tools/data	Agent to another agent
Main job	Give an agent capabilities	Let agents collaborate
Example	Marketing agent queries analytics	Marketing agent delegates qualification to sales agent
Interaction style	Structured tool/resource use	Higher-level task collaboration
Does one replace the other?	No	No

The official A2A documentation explicitly describes MCP and A2A as complementary standards.

An A2A agent can receive a complex task, reason about it, then use MCP tools underneath to perform the work.

The Marketing Problem We Are Building Around

Imagine a company receives leads through several campaigns.

Marketing knows:

• which campaign generated the visit
• what landing page the visitor used
• what content they interacted with
• which form they completed
• campaign cost and source information

Sales knows:

• existing CRM history
• previous conversations
• deal stage
• account status
• qualification notes
• previous opportunities

A single giant agent could theoretically receive access to everything.

But that is not always the cleanest architecture.

Instead, we can create specialized responsibilities.

Marketing Agent

Responsible for marketing context and campaign analysis.

Sales Agent

Responsible for CRM context and lead qualification.

The marketing agent does not need direct ownership of every sales capability. It can delegate the qualification task to the sales agent.

Step 1: Define the Marketing Agent's Job

Start with the business outcome, not the protocol.

The marketing agent's objective could be:

Identify high-intent marketing leads and prepare a prioritized follow-up report with evidence.

Its responsibilities might include:

1. retrieve recent campaign leads
2. inspect acquisition source
3. inspect relevant website behavior
4. identify leads showing stronger marketing intent
5. request sales qualification when CRM context is required
6. combine the findings
7. produce the final report

Notice that some steps require tools, while another requires another specialist.

That is exactly where the MCP/A2A split becomes useful.

Step 2: Give the Marketing Agent Tools Through MCP

The marketing agent needs access to marketing information.

Conceptually, its MCP layer might expose capabilities such as:

get_campaign_performance
get_recent_leads
get_landing_page_metrics
get_lead_source
get_content_engagement

The agent does not need to know the internal implementation of every system. It needs clearly described capabilities, the correct permissions and structured results.

A request might conceptually look like:

Get recent leads attributed to paid search campaigns
for the current reporting period.

The MCP-connected tool returns structured information.

The marketing agent then reasons over that result.

Important architecture rule

Do not expose every business system simply because you can.

Give the marketing agent the minimum tools and permissions required for its role.

Step 3: Define the Sales Agent

Now create a separate responsibility.

The sales agent's objective could be:

Evaluate a lead using approved CRM information and return a qualification summary.

Its MCP-accessible capabilities might include:

find_contact
get_account_history
get_open_opportunities
get_previous_interactions
get_lead_status

The sales agent can use those tools to perform its own investigation.

The marketing agent does not need direct access to all of them.

This creates a cleaner separation:

Marketing agent → marketing tools

Sales agent → sales tools

Step 4: Connect the Agents With A2A

Now we reach the part MCP alone does not solve as naturally.

The marketing agent discovers that it needs sales context for a promising lead.

Instead of directly querying every CRM tool, it delegates a task to the sales agent.

Conceptually:

Marketing Agent

Task:
Evaluate this lead for sales follow-up.

Return:
- current relationship
- qualification status
- relevant opportunity history
- reason for recommendation
- confidence or missing information

The sales agent receives the task through the A2A interaction.

It then uses its own MCP tools to investigate the CRM.

Finally, it returns the result to the marketing agent.

That gives us the core architecture:

MARKETING AGENT
   |
   |-- MCP --> Analytics / Marketing tools
   |
   |-- A2A --> SALES AGENT
                  |
                  |-- MCP --> CRM / Sales tools

Step 5: Let the Marketing Agent Combine the Evidence

The marketing agent now has two types of evidence.

Marketing evidence

For example:

• paid-search campaign
• high-intent landing page
• repeat website activity
• pricing-page visit
• form submission

Sales evidence

For example:

• existing account
• previous opportunity
• recent conversation
• qualified industry
• no active sales owner

The marketing agent can combine those findings into a useful recommendation.

Example output:

Priority: High

The lead arrived through a high-intent campaign, viewed the pricing page and submitted an inquiry. The sales agent found a previous opportunity with the same account but no currently active deal. Recommend sales review today.

The value comes from coordination, not simply adding another AI model.

Step 6: Add a Human Decision Where It Matters

A useful marketing-agent architecture should define where autonomy ends.

For example, the system can safely prepare:

• research
• prioritization
• summaries
• draft recommendations
• suggested follow-up

But you might require approval before:

• sending an important sales email
• changing CRM ownership
• modifying campaign budget
• publishing content
• changing pricing
• deleting records

The architecture then becomes:

Marketing tools
      |
     MCP
      |
Marketing Agent
      |
     A2A
      |
 Sales Agent
      |
     MCP
      |
  CRM tools
      |
Final recommendation
      |
Human approval

Step 7: Keep Deterministic Automation Around the Agents

Not every step should become agentic.

Suppose your rule is:

Every completed lead form must create a CRM record.

That does not require an AI agent to reason about anything.

Use normal automation.

A better architecture might be:

Form submitted → automation creates lead → marketing agent analyzes context → sales agent qualifies when needed → automation updates review queue → human approves action.

A simple rule is:

Use automation for predictable rules. Use agents for judgment. Use MCP for tools. Use A2A for collaboration.

A More Advanced Marketing-Agent Team

Once the two-agent architecture makes sense, it can expand.

A future system might contain:

Marketing Orchestrator Agent

Receives the overall marketing objective and coordinates specialized work.

Analytics Agent

Investigates campaign and website performance using analytics tools through MCP.

SEO Agent

Investigates search performance using search and content data through MCP.

Content Agent

Works with brand guidelines, approved assets and content systems.

Sales Agent

Investigates CRM context and qualification.

The orchestrator could communicate with these independent agents through A2A while each specialist uses its own MCP toolset.

But do not start here.

Two clearly defined agents are easier to test, debug and understand than six overlapping agents.

What Is an Agent Card?

A2A includes the concept of an Agent Card.

Think of it as a machine-readable introduction.

It helps another system understand information such as what an agent can do and how it can be reached. A2A v1.0 also adds signed Agent Cards for stronger identity verification in production environments.

For our example, the sales agent's advertised capability might conceptually be:

Agent: Sales Qualification Agent

Skill:
Evaluate a marketing lead using approved CRM context.

Returns:
Qualification summary and recommended next action.

The marketing agent can discover the relevant capability instead of being tightly coded around one proprietary implementation.

Why Not Just Make the Sales Agent an MCP Tool?

This is an important question.

If the capability is narrow, predictable and stateless, exposing it as a tool may be perfectly reasonable.

A2A becomes more useful when the remote system behaves like an independent agent that may:

• reason over a broader objective
• perform multiple steps
• use several tools
• maintain task state
• ask for additional information
• return complex results
• operate behind a different technology stack or organizational boundary

The official A2A guidance makes this distinction: MCP is oriented around tools and resources, while A2A supports richer collaboration between autonomous systems.

Do not use A2A merely because it is new. Use it when you genuinely have independent agents that need to collaborate.

Security and Permissions

Agent interoperability does not remove normal security requirements.

A production architecture should consider:

• authentication
• authorization
• least-privilege access
• data boundaries
• audit logs
• tool permissions
• approval rules
• rate limits
• sensitive information handling
• agent identity

A marketing agent should not automatically receive payroll access because another MCP server happens to expose it.

Likewise, an A2A connection should not imply unlimited trust between agents.

The protocol is infrastructure. Your business still defines the permissions.

A Practical Build Checklist

Before building anything, answer these questions:

1. What is the business outcome?

Example: prioritize marketing leads for sales follow-up.

2. What decisions require reasoning?

Those are candidates for agent work.

3. What steps are predictable?

Keep those as normal automation.

4. What tools does each agent need?

Those are candidates for MCP integrations.

5. What work belongs to another independent specialist?

That is where A2A may make sense.

6. What requires human approval?

Define it before deployment.

7. How will success be measured?

For this example, measure qualification accuracy, false positives, time saved, tool failures and human corrections.

The Architecture in One Sentence

If you remember only one thing, remember this:

The model is the brain, the agent is the worker, MCP gives the worker tools, A2A gives the worker specialized coworkers, and automation moves predictable work through the process.

That mental model is enough to start designing useful business-agent systems without turning every workflow into an unnecessarily complicated multi-agent project.

Frequently Asked Questions

What is the difference between MCP and A2A?

MCP standardizes connections between AI applications and tools, APIs or resources. A2A standardizes communication and collaboration between independent AI agents. They solve different layers of an agentic system and can be used together.

Does A2A replace MCP?

No. The official A2A documentation describes them as complementary. An agent can receive work through A2A and use MCP-connected tools to complete that work.

Can MCP connect two AI agents?

An agent capability can sometimes be represented in a tool-like way, but MCP is primarily designed around tools and resources. A2A is specifically designed for richer collaboration between independent agents.

What is an example of MCP in marketing?

A marketing agent could use MCP to retrieve campaign metrics, website analytics, content information or other structured business data through approved tools.

What is an example of A2A in marketing?

A marketing agent could delegate lead qualification to an independent sales agent, which performs its own investigation and returns a result.

Do small businesses need A2A now?

Most small businesses do not need a complex multi-agent architecture simply because the protocol exists. Start with one useful agent and clear tool access. Add another independent agent only when specialization or organizational separation creates a real benefit.

Is A2A production ready?

A2A v1.0 is described by the project as its first stable, production-ready release. Production use still requires appropriate security, permissions, observability and testing.

Should every marketing workflow use AI agents?

No. Predictable steps are usually better handled by deterministic automation. Agents are most useful where context, interpretation or judgment is required.

Final Takeaway

MCP and A2A are easier to understand when you stop thinking about protocols and start thinking about a team.

Your marketing agent needs tools. MCP can provide a standard way to reach them.

Your marketing agent may also need specialized coworkers. A2A can provide a standard way for independent agents to discover each other, delegate tasks and return results.

The useful architecture is not “AI everywhere.”

It is a deliberate combination of:

automation for rules + agents for judgment + MCP for tools + A2A for collaboration + humans for consequential decisions.

That is a much stronger foundation for building marketing agents that can eventually grow without giving one giant agent access to everything.

Sources

• A2A Protocol official documentation: https://a2a-protocol.org/latest/
• A2A Protocol v1.0 announcement: https://a2a-protocol.org/latest/announcing-1.0/
• A2A and MCP official comparison: https://a2a-protocol.org/dev/topics/a2a-and-mcp/
• A2A Protocol specification: https://a2a-protocol.org/dev/specification/
• Model Context Protocol: https://modelcontextprotocol.io/