7 days · about 28 hours

Multi-Agent Systems and the A2A Protocol in 7 Days: From In-Process Orchestration to Cross-Team Collaboration

For anyone who has built at least one agent. First, reproducible experiments answer when a task should be split across several agents and where information leaks at every handoff. Then you hand-build an A2A v1.0 server and client and treat another team's black-box agent as a teammate: discover it by its card, track it through tasks, trust it through signatures, and still deliver an honest result when something breaks.

Sign in and link WeChat to share one free article per day across both platforms. Unlock more with rewarded videos in the mini program.

Start day one

By the end

A portfolio-ready baton: four teams' agents plan a company offsite over A2A, hand back a one-page report that never lies, and ship with a conformance self-check labeled by section plus a recorded run of the official test kit

Measure when multi-agent systems win and when they lose with one set of cases and three topologies, then write handovers down as delegation briefs and result contracts. Hand-build an A2A v1.0 server and client with no SDK, adding the task lifecycle, streaming and cancellation, signed Agent Cards and authentication, and fault tolerance and push notifications for cross-team orchestration, and finally measure it with a conformance self-check and the official test kit

View account and linked status →7 days · about 28 hours

Week 1

From In-Process Orchestration to Cross-Team Collaboration, With Every Handover Made Checkable

D1🔒 Locked

When Should You Go Multi-Agent: Three First-Hand Sources and an Experiment That Reproduces Them

Start with three first-hand sources that point in opposite directions: one says splitting a task across agents scored ninety percent higher, one says do not split, and one gives the criteria. Then run the same batch of cases through a single agent, independent parallel agents, and centralized orchestration, using an offline model that knows nothing about the topology, and watch centralized orchestration win on parallelizable work, multi-agent lose on tightly dependent work, and the token bill multiply.

D2🔒 Locked

Handoffs: How Information Gets Lost Between Agents

Yesterday centralized orchestration lost to a single agent on tightly dependent work. Today you find out why and fix it: the orchestrator delegated without passing down the decisions it had already made and the constraints they carry, and the workers reported back without sources or dates. Write a delegation brief and a result contract, watch the dependent cases come back one by one, then strip the dates yourself and watch a stale fact slip into the final answer.

D3🔒 Locked

A2A Basics: Agent Cards, Discovery, and Your First SendMessage

Once a teammate is another team's black box, you cannot see its memory, its tools, or its reasoning. All you get is the card it publishes, the task status it reports, and the artifacts it hands back. Today you hand-build an A2A v1.0 JSON-RPC server and client, discover a peer through its card, complete your first synchronous task, and walk through every breaking change from v0.3 to v1.0 so you can reject the old-shaped requests that outdated tutorials still send.

D4🔒 Locked

Task Lifecycle: Long-Running Work, Streaming, Multi-Turn Input, and Cancellation

Another team's agent will not answer instantly. Today you give tasks a state machine and an event log: stream progress back chunk by chunk, resubscribe after a dropped connection without losing or repeating anything, pause to ask for missing information and carry on once it arrives, and cancel when the user no longer wants the result. Along the way you fix a bug that almost never shows up on a local machine: an SSE chunk boundary that falls in the middle of a multi-byte character.

D5🔒 Locked

Trust Across Teams: Authentication, Extended Agent Cards, and Signatures

Anyone can hand out a card, so why should you believe one? Today you sign agent cards, canonicalizing before you sign, and hit the most valuable trap in the whole course: sign without stripping default values first, and the signature stops verifying the moment the other side serializes the card differently. Then you move authentication from declaration to enforcement, give the finance team an extended card only authorized callers can see, complete an auth-required task with an out-of-band credential, and finally isolate each tenant's tasks from every other tenant.

D6🔒 Locked

Orchestrating Other Teams' Agents: Routing, Fault Tolerance, and Push Notifications

Move the centralized orchestration from Day 2 onto A2A and call the agents of four teams. Route by skill, and fail loudly instead of picking someone at random when nothing matches. Retry on timeout, but reuse the same message ID so the other side never does the work twice. When one team goes down, deliver an honest result that says what is missing. When the user cancels, carry the cancellation to every downstream task. Finally, replace long-held connections with push notifications and block the SSRF hiding in the push URL.

D7🔒 Locked

Capstone: A Company Offsite Planned Across Four Teams, Plus a Conformance Self-Check

Wire the modules from the first six days into one pipeline: four teams run their agents on their own ports, and the orchestrator discovers them by card, trusts them by signature, delegates through briefs, collects reports through contracts, and still hands back a report anyone can read at a glance when something fails. Then pick the must-level requirements out of the specification, turn them into a conformance self-check, compare it with the official conformance test kit, and look back over the seven days.