MCP vs A2A vs ACP：AI代理如何真正相互对话
本文介绍MCP、A2A与ACP三种AI代理通信协议：MCP用于代理与工具通信，A2A用于代理间通信，ACP已并入A2A；生产环境中MCP与A2A互补。
中文处理结果
你的AI代理有一个盲点（赞助）
随着AI代理承担决策任务，它们需要了解现实世界的状况。
天气延误可以改变配送路线。闪电可以暂停现场作业。路况可能影响自动驾驶车辆。这些信号影响决策，但大多数AI系统无法观察它们。
但上下文的价值取决于其背后的数据。企业应用需要可信、实时的天气情报——不仅仅是通用预报。闪电活动、路况、冰雹风险和天气影响等信号往往比单独的温度更重要。
Xweather的MCP就绪天气API为AI代理提供可信的天气情报以及天气驱动决策背后的现实世界上下文。在本技术指南中了解其工作原理。
获取您的免费API密钥
本周系统设计复习：
- MCP vs A2A vs ACP：AI代理如何真正相互对话
- 我最期待的8个前沿开放模型
- LLM vs RAG vs 代理评估
- 高层分布式追踪如何工作？
- Redis查询的生命周期
MCP vs A2A vs ACP：AI代理如何真正相互对话
代理本身就能干。结合工具和其他代理后，它们的能力会复合增长。但它们应该如何沟通？
- MCP：代理到工具的通信。 主机应用接收用户请求，其嵌入的MCP客户端格式化并将其路由到正确的MCP服务器，服务器执行工具调用并返回结构化响应。代理使用结果继续推理。
- A2A：代理到代理的通信。 无法单独完成任务的代理通过其代理卡（发布在众所周知的URL上）发现一个有能力的同伴，委派任务，并接收结构化结果。如果第二个代理在任务中途需要更多输入，它会暂停在输入必需状态并循环回第一个代理。
- ACP：通过REST的代理到代理通信（已并入A2A）。 ACP采用REST优先的方法。同伴通过代理清单发现，直接通过HTTP调用，并同步响应低延迟任务或通过异步SSE流响应。
在生产中，MCP和A2A是互补的。MCP处理工具访问，A2A处理代理通信。
你是否在你的代理栈中同时运行MCP和A2A？
介绍Attio：Agentic CRM。（赞助）
Attio，Agentic CRM，让任何人都能极其轻松地为任何所需的GTM策略运行工作流。
描述你想要的，Attio就会构建它。我刚刚构建了一个工作流，每天早上运行，显示今天需要我关注的交易，比如过去24小时内任何阶段变化或新信号。
每天已有数十万个自动化在Attio上运行。准备好试试了吗？
今天就试试。
LLM vs RAG vs 代理评估
LLM、RAG管道和代理是不同的系统，但评估它们的秘诀相同：选择任务，收集评估数据，开发评分器。
下图分解了四种主流AI系统的评估方法。
原始正文摘录
MCP vs A2A vs ACP: How AI Agents Actually Talk to Each Other
Your AI agent has a blind spot (Sponsored)
As AI agents take on decision-making, they need awareness of real-world conditions.
A weather delay can reroute deliveries. Lightning can pause field operations. Road conditions can affect autonomous vehicles. These signals shape decisions, yet most AI systems can’t observe them.
But context is only as valuable as the data behind it. Enterprise applications need trusted, real-time weather intelligence—not just generic forecasts. Signals like lightning activity, road conditions, hail risk, and weather impacts often matter more than temperature alone.
Xweather’s MCP-ready weather API gives AI agents access to trusted weather intelligence and the real-world context behind weather-driven decisions. Learn how it works in this technical guide.
Get your free API key
This week’s system design refresher:
- MCP vs A2A vs ACP: How AI Agents Actually Talk to Each Other
- 8 Frontier Open Models I’m Most Excited About
- LLM vs RAG vs Agent evals
- How Distributed Tracing Works at the High Level?
- The Life of a Redis Query
MCP vs A2A vs ACP: How AI Agents Actually Talk to Each Other
Agents are capable on their own. Combined with tools and other agents, their capabilities compound. But how should they communicate?
- MCP: agent to tool communication. The host app receives the user request, its embedded MCP client formats and routes it to the right MCP server, the server executes the tool call and returns a structured response. The agent uses the result to continue reasoning.
- A2A: agent to agent communication. An agent that can't complete a task alone discovers a capable peer via its Agent Card (published at a well-known URL), delegates the task, and receives a structured result back. If the second agent needs more input mid-task, it pauses in the input-required state and loops back to the first.
- ACP: agent to agent communication over REST (merged into A2A). ACP took a REST-first approach. Peers were discovered through an Agent Manifest, called directly over HTTP, and responded to sync for low-latency tasks or via async SSE stream.
In production, MCP and A2A are complementary. MCP handles tool access, A2A handles agent communication.
Are you running MCP and A2A together in your agent stack?
Introducing Attio: the agentic CRM. (Sponsored)
Attio, the agentic CRM, makes it incredibly easy for anyone to run workflows for any GTM play they need.
Describe what you want, and Attio builds it. I just built a workflow that runs every morning, surfaces the deals that need my attention today, like anything with a stage change or a new signal in the last 24 hours.
Hundreds of thousands of automations already run on Attio every day. Ready to try now?
Try it today
LLM vs RAG vs Agent evals
LLMs, RAG pipelines, and agents are different systems, but the recipe for evaluating them is the same: pick a task, collect eval data, develop a grader.
The diagram below breaks it down across four popular AI systems.
- LLMs: Input is a prompt, output is text. Tasks focus on what a raw model can do on its own: safety, code, instruction-following. Grader is often LLM-as-judge on the final answer.
- RAG: Adds a retriever before the LLM. So you grade two things: retrieval (right docs?) and generation (faithful answer?).
- Coding Agents: The LLM gets tools and a loop. Tasks become end-to-end like bug fixing and long-horizon planning. Grading is mostly code-based: run unit tests on the final patch.
- Multi-Agent Systems: Multiple agents coordinating through an orchestrator. Tasks shift to coordination and role adherence. Grading blends code tests, LLM-as-judge, and human review.
Every new component in the pipeline is a new place for things to go wrong, and a new thing your evals need to catch.
Over to you: What's your go-to evaluation metric for multi-agent systems?
8 Frontier Open Models I’m Most Excited About
- Inkling (Thinking Machines): released this week, now the strongest American open model. Text, image, and audio input.
- Nemotron 3 Ultra (NVIDIA): a solid choice for long-running agents. The Mamba hybrid keeps long-context inference cheap.
- GLM-5.2 (Z.ai): currently the best open model for coding.
- Kimi K2.6 (Moonshot): strong on long agent tasks. Holds up over hundreds of tool calls.
- DeepSeek-V4 Pro: a very cheap way to get frontier-level quality over an API.
- Qwen3.6-35B (Alibaba): the best model to run on your own machine. A single 24 GB GPU is enough.
- Gemma 4 31B (Google): the best choice for on-device multimodal. Takes image and audio input on a gaming GPU.
- MiniMax M3: the only open model with native video input.
Over to you: Which open model are you most excited about?
How Distributed Tracing Works at the High Level?
- Services generate telemetry data (traces, logs, metrics) as they handle requests.
- The OpenTelemetry Collector receives this data from all services in a unified format.
- The collector splits the data into three streams: traces, logs, and metrics.
- Each stream is sent to a Receive & Process unit that prepares it for storage and analysis.
- Processed data is stored in a Log Database for querying and long-term access.
- Data from the database is visualized through a Visualization dashboard for monitoring and debugging.
Over to you: What else will you add to better understand distributed tracing?
The Life of a Redis Query
Redis is an in-memory database, which means all data lives in RAM for speed. However, if the server crashes or restarts, data could be lost.
To solve this problem, Redis provides two persistence mechanisms to write data to disk:
- AOF (Append-Only File)
When a client sends a command, Redis first executes it in memory (RAM). After that, Redis logs the command by appending it to an AOF file on disk. This ensures every operation can be replayed later to rebuild the dataset. Since the command is executed first and logged afterward, writes are non-blocking. The recovery process uses the event log to replay the recorded commands.
- RDB (Redis Database)
Instead of writing every command, Redis can periodically take snapshots of the entire dataset.
The main thread forks a subprocess (bgsave) that shares all the in-memory data of the main thread. The bgsave subprocess reads the data from the main thread and writes it to the RDB file.
Redis uses copy-on-write. When the main thread modifies data, a copy of the data is created, and the process works on that so that writes don’t get blocked. The snapshot is then written as an RDB file on disk, allowing Redis to quickly reload the snapshot into memory when needed.
- Mixed Approach
In production, Redis often uses both AOF and RDB. RDB provides fast reloads with compact snapshots. AOF guarantees durability by recording every operation since the last snapshot.
Over to you: Have you used Redis in your project?