AI agent protocols compared: MCP, RAG, A2A, ACP

Quick comparison

• RAG: retrieves relevant knowledge so a model can answer with external context.
• MCP: connects AI applications to tools, resources, prompts, and integration servers.
• A2A: enables one agent to communicate, delegate, and exchange artifacts with another agent.
• ACP: describes a control or admission layer for deciding whether agent actions should execute.
• Agentic AI: the broader system pattern where models plan, use tools, remember context, and complete multi-step work.

How they fit together

Imagine a research-to-execution workflow. RAG retrieves internal documents and prior decisions. MCP exposes tools such as GitHub, cloud inventory, or a ticket system. An agentic workflow plans and performs the task. A2A allows a specialized research agent to ask a specialized engineering agent for help. ACP-style controls stop risky actions until policy and approval checks pass.

None of these ideas needs to replace the others. They are layers in a useful agent system.

When to use each concept

Use RAG when the model needs private, current, or source-grounded knowledge. Use MCP when the agent needs structured access to tools or external systems. Use A2A when work should be delegated between specialized agents. Use ACP-style controls when the agent can change real systems and needs policy enforcement. Use agentic workflow design when the job requires multiple steps, artifacts, and memory.

Example architecture

Consider an engineering review workflow. A user asks for a release readiness review. The system retrieves prior architecture notes and deployment runbooks through RAG. It uses MCP tools to inspect repository files, CI results, and cloud deployment metadata. An agentic planner turns the request into steps. If another specialized security agent is available, the workflow can delegate a security review through A2A. Before production changes, an ACP-style control checks policy and asks for approval.

This layered model helps teams avoid category confusion. Each concept has a job. Together, they support a safer and more capable agent system.

Questions for builders

• Where does the system get trustworthy knowledge?
• Which tools and resources should agents be able to access?
• Which actions are read-only, and which mutate external state?
• When should work be delegated to another specialized agent?
• What policies decide whether an action can execute?
• How are artifacts, approvals, and outcomes audited?

These questions help turn abstract protocol discussions into product architecture decisions.

Common adoption path

Most teams begin with grounded answers. That means RAG and knowledge bases. Next, they add tools through MCP-style integrations. Then they turn repeated tasks into agentic workflows. As workflows become more specialized, agent-to-agent coordination becomes relevant. As agents get closer to production systems, control protocols and approval layers become necessary.

This adoption path is practical because each layer creates value before the next layer is required. Teams do not need every protocol on day one. They need the next layer when the current workflow exposes a real need.

Common confusion

MCP is not the same thing as RAG. A RAG system might use an MCP server to access documents, but RAG is the retrieval pattern and MCP is the integration protocol. A2A is not the same as MCP either. A2A is agent-to-agent communication, while MCP is usually agent-to-tool or host-to-server integration. ACP is not a retrieval or tool protocol; it is a governance/control concept.

Agentic AI is the umbrella. Protocols and patterns are the supporting structure.

Learning path

1. Learn RAG to understand knowledge grounding.
2. Learn MCP to understand tool and resource integration.
3. Learn agentic workflows to understand planning and execution.
4. Learn A2A to understand multi-agent interoperability.
5. Learn ACP-style controls to understand governance before mutation.

That sequence mirrors how many teams adopt agents: first answers, then tools, then workflows, then multi-agent coordination, then deeper governance.

How Kendr frames the space

Kendr focuses on making these concepts usable for real work. Deep research and knowledge bases cover the RAG side. Skills and MCP packs cover tool integration. Agentic workflows cover planning and execution. Approval-aware design brings ACP-style control thinking into practical workflows.

Start with RAG explained, MCP explained, or agentic AI systems explained.

Protocol selection checklist

• If the problem is "the model needs our documents", start with RAG.
• If the problem is "the model needs to use tools", look at MCP.
• If the problem is "specialized agents need to collaborate", look at A2A.
• If the problem is "agents may change real systems", add ACP-style controls.
• If the problem is "the work has multiple steps", design an agentic workflow.

The healthiest systems usually combine several of these ideas, but each should be added because it solves a real architectural problem.

Practical takeaway

Protocol conversations can become abstract quickly. A better approach is to map each protocol to a user workflow. If the workflow needs knowledge, design retrieval. If it needs tools, design MCP-style integration. If it needs specialized delegation, design agent-to-agent handoff. If it can mutate systems, design control and approval.

This keeps architecture connected to product value. The goal is not to collect protocols. The goal is to help agents do useful work with context, safety, and accountability.