Agent-to-Agent Communication Concepts

Version note — reviewed 2026-09-29. The official A2A specification site still labels v1.0.0 as the latest released specification. The A2A repository also publishes a v1.0.1 patch release with specification bug fixes. This Lesson remains pinned to the published v1.0.0 specification and treats the patch release as compatibility/release-note evidence.

Goal

Explain how A2A v1.0.0 lets independent agent systems discover capabilities and collaborate without exposing their private internal memory or tools.

A remote specialist can take time

Suppose a support agent needs a specialist to analyze a large server log. The local agent does not have that skill, so it looks for a remote agent that advertises log_analysis and structured output.

The remote specialist is not just a function that returns immediately. It may accept the job and work for several minutes. It may ask for one missing detail or send progress updates. Later, it may return a report artifact. The parent therefore needs a remote task ID and a way to follow that task over time.

The parent should not need the specialist's private memory, hidden reasoning, or internal tool list. It needs only the visible information required for the job. That includes enough information to choose the specialist, send the task, follow its status, and receive the expected result.

A2A v1.0.0 provides shared protocol objects for this kind of collaboration. The two agent systems can use different frameworks or languages. They communicate through visible capabilities, messages, tasks, and artifacts.

Discovery starts with an Agent Card: a machine-readable profile that lists an agent's advertised capabilities and supported interfaces. The card helps the parent decide whether the agent looks suitable. It does not grant permission by itself.

Discover capabilities with Agent Cards

Match capabilities explicitly. If the task needs structured output and the remote agent does not advertise a compatible interface, choose another agent or stop. Do not assume the remote side will improvise correctly.

The remote agent can stay opaque. That means its private internals stay private. Collaboration can use visible messages, task status, and artifacts instead of hidden reasoning or a private tool list.

Agent Card → choose compatible agent → create child task → messages/status → artifact

Identity and authorization still matter. An Agent Card helps with discovery, but the client must still verify the endpoint and use the right credentials. Give the remote agent only the data and authority needed for this task.

Keep identity and budgets local

Delegation also keeps the Level 12 budget rules. Record the child task ID, deadline, expected artifacts, and time or cost limit. A remote agent does not remove the parent's limits.

Errors and unsupported capabilities need a fallback path. The parent might choose a different remote agent, simplify the task, or ask the user. Repeating the same incompatible request is not a recovery strategy.

Plan fallback and failure

The key mental shift is that interoperability lets two harnesses coordinate through visible protocol objects. Each side remains responsible for its own internal policy, execution, and safety.

Predict

A remote agent can solve a task but does not expose its internal tools or memory. Is collaboration still possible under the A2A model?

Yes; the protocol is designed around externally visible capabilities, messages, tasks, and artifacts rather than internal implementation accessNo; the client must inspect the remote chain of thought before delegationOnly if both agents use the same model provider and framework

Run the local Lab

Run:

python3 labs/notebooks/level-13/l13-07-a2a-concepts.py

The Lab compares Agent Card-like fixtures against a required skill and interface.

1. Run it unchanged. With required_skill="log_analysis" and required_interface="structured", only log-agent should match.
2. Before editing, predict how the match set will change if the task requires text instead. Both log-agent and log-lite advertise that interface, but only agents with the required skill remain eligible.
3. Change only required_interface="structured" to required_interface="text", then rerun.
4. Confirm that the matches become log-agent and log-lite, while travel-agent remains excluded because its skill is unrelated.

Loading lab…

Quick Check

1. What is a main purpose of A2A?

Enable independent agents to discover and collaborateForce all agents to use the same frameworkExpose every remote agent's private memory and tools to its caller

2. What does an Agent Card primarily support?

Discovery of capabilities and interfacesAutomatic trust of every advertised actionReplacing the need for authentication checks

3. Which record lets the parent audit and control a delegated task?

The final answer without child identity or limitsThe remote agent's private reasoning transcriptChild task identity, expected artifacts, limits, and trace evidence

0 of 3 questions answered.

Explain it back

Describe how a parent agent could select a remote specialist using an Agent Card, delegate a bounded task, and track the work without seeing the specialist's internal memory.

Key Takeaways

• A2A v1.0.0 targets independent agent-system interoperability.
• Agent Cards support capability and interface discovery.
• Remote internal memory and tools need not be exposed.
• Parent budgets and policy still apply to delegation.
• Compatibility and trust remain separate checks.

Next Lesson

Next, L13.8 — A2A Messages, Tasks, and Artifacts examines the protocol objects that carry collaboration.

References

• Agent2Agent Protocol, v1.0.0 Specification.
• Agent2Agent Protocol, official release notes.