Free sample lesson ยท SHAREDCOURSE PRIVMARK47b357739859

Motivation Why Agents to Coordination Protocols

Why connect Motivation Why Agents through Coordination Protocols?

Lesson 1 of the Wondering course SHAREDCOURSE PRIVMARK47b357739859

Why Agents Must Communicate

One agent rarely does everything alone.

In an agentic AI system, a planner might hand work to a research agent, which hands results to a writing agent. Each one holds part of the job.

Three AI agents passing work along a chain

Notice that each agent holds only one part of the job, so the chain breaks if any handoff of tasks, context, or results fails.

If they cannot exchange tasks, context, and results reliably, the whole system stalls or quietly drifts.

That need is the motivation behind shared protocols such as Google A2A (Agent2Agent).

A Decision Boundary, Not a Label

This lesson groups several ideas into one cluster: why agents communicate, the A2A design philosophy, agent cards, the task lifecycle, and streaming.

Treat the cluster as a decision boundary. Before choosing a technique, ask three questions.

What mechanism changes? What assumption does it rely on? What evidence would verify it works?

Questions to ask before choosing

A useful first check: which component owns the state, objective, context, or verification signal?

Agent Cards: Finding Who Can Help

Before one agent can delegate, it needs to know who can help.

  • Agent card: Public self-description for discovery.
  • Who it is: Identifies the agent.
  • Skills offered: What work it claims it can do.
  • How to reach it: Where other agents send tasks.

An agent card is a short public description an agent publishes about itself: who it is, which skills it offers, and how to reach it.

The mechanism is discovery. The assumption is that the card is accurate and current.

Evidence: send a small test task and confirm the agent actually does what its card claims.

The Task Lifecycle

In A2A, work is organized as a task that moves through states.

A client agent submits a task. The remote agent works on it. Sometimes it pauses because it needs more input, then continues.

Finally the task ends as completed or failed.

How a task moves
  • Task submitted: A client agent sends the task.
  • Working: The remote agent works on it.
  • Needs more input?
  • Input required: The task pauses until input arrives.
  • Succeeded?
  • Completed
  • Failed
  • continues

The assumption: both sides agree on the current state. If they disagree, work gets duplicated or lost. Verify by logging every state change.

Streaming With Server-Sent Events

Some tasks take a long time. Waiting silently for one final answer leaves the client agent blind.

Server-Sent Events (SSE) let the remote agent push progress updates over an open connection while the task runs.

Two ways to hear back
  • One final answer
  • Streamed updates

The assumption is that the connection stays open and updates keep arriving.

Evidence: interrupt a long task on purpose and check whether the client notices and recovers.

The Common Mistake

A frequent error is treating this cluster as a list of labels to memorize.

Knowing the words agent card or SSE does not tell you whether they fit your system.

Each piece is a tradeoff to test. Streaming adds visibility but depends on stable connections. Agent cards enable discovery but depend on honest, current descriptions.

Picking a technique without checking its assumption is how quiet failures enter.

Which assumption are you trusting blindly?

Applying It to a Scenario

Here is a made-up example: a research agent hands a report task to a writing agent, but the final report never arrives.

Walk the cluster. Did discovery work through the agent card? Where did the task state stop? Did streamed updates go silent?

Diagnose any handoff
  • Find the piece: Decide whether discovery, task state, or streaming is involved.
  • Find the owner: Ask which component owns the state, objective, context, or verification signal.
  • Name the failure: State what failed and which assumption broke.
  • Verify: Run one check, such as a test task or state log, to confirm it.

Name what failed, the assumption that broke, and one check to confirm it.

That habit is the real takeaway.

Check yourself

Topics like agent cards, task lifecycle, and streaming are best studied as _____

  • system tradeoffs to test in a real design
  • labels to memorize with their exact names

Answer: system tradeoffs to test in a real design

A common mistake is to treat these topics as labels to memorize. Each one is a design tradeoff. You should be able to say when it applies, what can fail, and how to check it.

For any agent communication design, ask what _____ changes, what _____ it relies on, and what _____ would verify it.

Answer: For any agent communication design, ask what mechanism changes, what assumption it relies on, and what evidence would verify it.

Three questions guide each design choice: what part of the system changes (mechanism), what must be true for it to work (assumption), and what proof shows it works (evidence).

You are building a system where several AI agents must talk to each other. Before you pick an implementation, what is the most useful first question to ask?

  • Which component owns the state, goal, context, or check?
  • Which agent communication tool is the most popular today?
  • How many agents can fit into the system at once?
  • Which section names should the team memorize first?

Answer: Which component owns the state, goal, context, or check?

The first step is to find out which component owns the state, goal, context, or check. That tells you where communication is needed. Popularity, headcount, or memorized names don't show where communication matters.

Keep going

This is lesson 1 of 16 in SHAREDCOURSE PRIVMARK47b357739859. Next up:

  1. A2A vs MCP to Multi-Agent Architectures
  2. Coordination Mechanisms to Challenges Solutions
  3. Real-World Multi-Agent Applications to Agent Development Lifecycle
  4. Major Frameworks Deep to Framework Comparison
  5. Complete Implementation Example to Frameworks Libraries

Start this course free

Wondering turns any topic into short lessons you can read, watch, or listen to, with practice questions and an AI tutor.