The A2A card said 0.0.0.0:8080, and the only caller it broke was Google's

A bind address and a dial address are two different facts that happen to be the same string on a laptop ^[7]. That coincidence is the whole mechanism. `to_a2a(agent, host, port)` writes host and port straight into the interface URL the agent card advertises, and on Cloud Run the process binds `0.0.0.0:8080`, so a public HTTPS service publishes unroutable plaintext as its address ^[6][5]. A2A callers resolve that card at `/.well-known/agent-card.json` and dial what it says, over JSON-RPC, at protocol version 1.0 ^[4]. Local tests cannot see the defect, because locally the card is right.

The Strands agent on Bedrock AgentCore and the Agent Framework agent on Container Apps both take a `PUBLIC_URL` and advertise that ^[8]. Count the deployments: of three agents speaking the same protocol version, one publishes the address it listens on and two publish the address a stranger can reach ^[1]. That is an argument-list difference, not a verdict on frameworks, and it surfaces only when the resolver is somebody else.

The sharper detail is who found it. The all-first-party pairing, ADK client against ADK server, is the one hop that cannot complete, because both halves pass Google's own tests on the laptop identity ^[9]. When the client does fail, it fails at the wrong layer: `RemoteA2aAgent`'s handler assumes every `A2AClientError` carries a status code, which a transport failure does not, so the operator receives `AttributeError: 'A2AClientError' object has no attribute 'status_code'` while `All connection attempts failed` lands on a separate log line ^[10]. One defect sends the client somewhere unroutable, the second deletes the evidence of where it went ^[10].

Reply placement is the same species of problem with a worse failure mode. ADK's executor attaches the answer as a task artifact and also leaves a copy in task history ^[12]. Microsoft's `A2AExecutor` drives the full task lifecycle and leaves the answer only in history, artifacts empty ^[13]. A client that reads artifacts alone is the obvious implementation, works against ADK, and returns an empty string against Agent Framework: a successful call, no error, no timeout, no content ^[14]. Read every carrier the spec allows and ADK's reply now arrives twice ^[15]. So no single-carrier read is correct against both servers, and the both-carrier read is only correct with deduplication bolted on ^[2].

An earlier version of the same project hid that entirely. The agents returned exchange rates, and the parser indexed quotes by target currency, so the duplicate overwrote the original and the answer came out correct ^[16]. The payload shape was doing the deduplication, silently, for free, until the payload changed.

Both findings share a precondition, and it is not the framework. `to_a2a()` really is the shortest path from an `LlmAgent` to something another vendor's agent can call ^[3]. The path is short because it assumes the caller shares your process view. The author's operational advice is narrow and correct: fetch your own card after every deploy, and if you cannot fix the card, make your callers rewrite the interface URL after resolution rather than routing by it ^[11]. Which is to say that on today's A2A, the card is a hint, and the client owns the address.