Part 8 of 10 · 4 min read
Interview answers and mistakes
Answering "A2A or MCP, and why?" in an interview
I would use MCP when the other side is a capability I can describe with a schema and test as code. I would use A2A when it is a separate agent run by someone else. Such an agent may take a long time, ask me questions partway through, and need the person's permission. I should not have to understand it internally. In practice the same system often uses both. An agent calls tools over MCP and calls other agents over A2A. The hard part in either direction is carrying the user's identity and the task's state across the boundary correctly.
I would not claim A2A is strictly required for long-running work now that MCP has a Tasks extension. The gap between the two protocols has narrowed, and the honest answer names that instead of repeating the old slogan. A2A still gives you two things a tool call does not. One is a task that can sit in INPUT_REQUIRED or AUTH_REQUIRED as a first-class state. The other is a card that an agent publishes about itself, rather than a schema the caller writes.
Follow-ups worth preparing for: "What can a client actually trust in a card?" The answer is almost nothing unless it is signed by a key the client provisioned. The card is a claim, not a fact. "How do you keep a delegation chain honest?" Exchange a narrowly scoped token naming the delegate as actor. Never pass the original token through or share one service token across users. "How do you know your conformance suite would catch a real regression?" Plant defects and predict which checks fail before running them. This is the same discipline as mutation testing in module 6.
Mistakes that undercut an agent-to-agent design
- Trusting an unsigned card because it came from a plausible-looking domain. Symptom: a routing step sends real traffic to an agent nobody vetted. Cause: the client never checked for a signature, or checked it against a key fetched from inside the card. Fix: refuse unsigned cards for anything that matters, and only trust keys collected out of band.
- Letting a delegate pass the user's original token straight through. Symptom: the downstream agent's audience check accidentally passes, or the delegate ends up able to act as the user indefinitely. Cause: pass-through was chosen because it was the least code to write. Fix: exchange for a new, narrowly scoped, short-lived token naming the delegate as actor.
- Resolving a push URL once at registration and trusting it forever after. Symptom: a webhook address that was public at setup time later resolves to an internal address, and the server happily calls it. Cause: the guard ran once, and the connection re-resolved the name later. Fix: pin the checked address and connect to that, not to a fresh lookup of the name.
- A tool wrapper that blocks until the remote task finishes. Symptom: every long job times out from the caller's side, even though the remote agent is working correctly. Cause: the wrapper has no timeout shorter than the host's own, so it loses the task id along with the answer. Fix: give the wrapper its own limit and return the task id with a "still working" status before that limit is hit.
- Trusting a conformance suite's green run without ever planting a defect. Symptom: a protocol regression ships, and nothing in CI caught it. Cause: the suite was never tested against a known-broken server. Fix: plant realistic defects, predict which checks should fail, and treat any defect that escapes as a documented hole, not a surprise discovered in production.
Check yourself
An Agent Card says the agent handles payments and is run by your bank. How much of that can a client rely on?
Show answer
Almost none, unless the card is signed by a key you provisioned. A card is a claim, not a fact.
For the curious A2A and MCP overlap
The slogan that MCP is for tools and A2A is for agents hides that an agent can sit behind a tool and a tool can be described as an agent. The useful differences are a task that outlives a request, the two pauses (a question, a missing credential), and how the user identity is carried to the other agent.
What you will use daily at work
| Practice | What it looks like |
|---|---|
| Task ids | A long job returns an id you can poll, stream, or be notified about. |
| Delegation | Pass the user identity on, not the calling agent own. |
| Conformance tests | A suite tied to the protocol rules, checked by planting defects. |
Quick notes: what you must be able to say
- A card is a claim; the only verifiable part is a signature checked against a key the client provisioned itself, never one fetched from the card.
- A task carries state (status, history, artifacts) across time, and its transition table must be written down and enforced in one place.
- Polling spends the caller's requests, streaming spends an open connection, and push spends a public receiver the server must guard against SSRF.
- Delegation should exchange a new, narrowly scoped token naming the delegate as actor — never pass the original token through or share one service token.
- A conformance suite is only worth what it would catch: plant defects and predict which checks fail before you run them.