ChangeGamer

How to Verify a Remote A2A Agent Before Delegating

Part 7 of A2A in practice: agent-to-agent interoperability · 1,469 words · ~7 min read · published · updated · Markdown variant

What a signed Agent Card proves and does not, how domain, key and ERC-8004 identity differ, where Web Bot Auth fits, and why card text and returned artifacts are untrusted input, ending in an ordered checklist.

In short

  • Verifying a remote A2A agent before delegating means checking who published its Agent Card, treating its card text as untrusted input, and treating everything it returns as untrusted output.
  • A signed A2A Agent Card shows that the holder of a signing key published that exact card; the A2A reference does not claim the signature says anything about whether the agent behaves well.
  • Signing an Agent Card is optional in A2A, so an unsigned card proves nothing about who published it, and a client should not delegate sensitive work on the strength of one.
  • ERC-8004 was a Draft Ethereum standard as of 13 October 2026, and its own text says it cannot cryptographically show that an agent advertised capabilities work or are non-malicious.
  • Web Bot Auth signs HTTP requests to prove who is calling an origin server, so it identifies a requester and does not vouch for a remote agent you are about to call.

Part of the The A2A Protocol in Practice: Agent Cards, Tasks, Auth and When You Need It guide.


Verify a remote A2A agent in layers: confirm who published its card, decide how far that identity is trusted, treat the card text as hostile until reviewed, and treat everything it returns the same way. The A2A protocol reference (updated 27 October 2026) states the card and signing contract. The A2A pillar covers the protocol; this article covers only the decision before the first delegated task.

What does a signed Agent Card actually prove?

A signed card proves control of a signing key over exact card contents, and nothing about behaviour. The A2A specification (https://a2a-protocol.org/latest/specification/, read 5 November 2026) says "Signatures allow clients to verify that an Agent Card has not been tampered with and originates from the claimed provider" and "Clients SHOULD verify signatures when present". Signing itself is optional, so an unsigned card proves nothing about who published it. The mechanics are covered in the pillar and in Agent Card design; this section covers only what the signature leaves open.

Narrowing the spec's "claimed provider" wording (inference): a signature proves control of a key, not that the key belongs to the organisation the card names.

How does a client decide which signing key to trust?

The specification offers key-lookup mechanisms but no trust anchor. As read on 5 November 2026, it allows multiple signatures on a card, which supports key rotation; its JWS header examples use kid (key ID) and jku (a JWKS URL); and keys are retrieved via those or "from a trusted key store". It says expired or revoked keys MUST NOT be used for verification, but it defines no rotation procedure, and trust anchoring and a rotation or revocation procedure are unspecified.

A jku URL is chosen by the publisher, so fetching a key from it proves control of that origin only, not that the origin is who you meant to deal with (inference). Settle the anchor yourself, for example by pinning a key obtained out of band, or by holding a trusted key store you maintain.

The spec's SHOULD to verify signed cards is a floor, not a verdict.

How is a remote agent's identity established: domain, key or onchain?

Three identity anchors exist, and they answer different questions. Pick by what you need to be able to say afterwards.

Anchor What it ties together Limit
Domain The card is served from https://{server_domain}/.well-known/agent-card.json, which shows the card was served from that origin Proves control of the origin, not the agent's quality
Signing key A JWS signature over the canonical card Only as good as how you came to trust the key
ERC-8004 identity An ERC-721 token whose owner owns the agent, with a URI to a registration file listing endpoints Draft standard; ties a file to an onchain agent, not to good behaviour

The ERC-8004 reference records the status as Draft (Standards Track: ERC) on 13 October 2026 and says drafts can change. No adoption figure for it, or for A2A signed cards, is published in the corpus, so none is claimed here. Its optional supportedTrust field matters: if absent or empty, the registration is for discovery only, not trust.

Where does Web Bot Auth fit?

Web Bot Auth fits at the request edge only: it lets a caller prove its identity to an origin server using HTTP Message Signatures (RFC 9421). The Web Bot Auth reference (updated 7 August 2026) describes a signed key directory, Signature-Input, Signature and Signature-Agent headers, and a receiving origin that verifies them.

Direction decides its use. If a remote agent calls your server, Web Bot Auth can tell you who is calling. If you are deciding whether to delegate to someone else's agent, a signature scheme for requests tells you nothing about that agent's card or conduct. The A2A reference does not describe Web Bot Auth as part of A2A, so any pairing is your design choice (inference).

Why are reputation and validation signals weak?

Reputation and validation signals are weak because the party being rated can influence them and their meaning depends on who you trust. The ERC-8004 reference lists the limits directly.

Use these signals to rank candidates, not to authorise a delegation.

Why is Agent Card text untrusted input?

Agent Card text is untrusted input because the card is self-published. The corpus A2A entry states this as inference, not spec text: treat skill descriptions as untrusted input to your model, like MCP tool descriptions. The pillar's untrusted card text section owns the argument; this section only maps the defence onto cards.

The MCP tool poisoning reference (updated 9 October 2026) gives a pin, scan, confirm checklist. Applied to an Agent Card (inference, no published A2A incident is cited here):

  1. Pin: hash the approved card and block or re-prompt when it changes. A changed description after approval is the "rug-pull" pattern from MCP, applied to cards (inference).
  2. Scan: check name, description and skill text for model-directed imperatives, sensitive paths and exfiltration patterns before the text reaches a model.
  3. Confirm: keep a human confirmation on high-impact delegations.

Are returned artifacts and messages trusted?

No, returned messages and artifacts are untrusted output from a party you do not control. A2A messages carry text, file or structured data parts, and any of them can contain instructions aimed at your model or malformed content aimed at your parser.

The MCP guidance in the poisoning reference says clients should validate tool results before passing them to the LLM, and the same posture transfers (inference). Concretely: check structured parts against the schema you expect, treat text parts as data in the prompt and not as instructions, scan file parts before opening them, and never let a returned value choose a tool, a recipient or a payment amount without your own policy check. A task that reaches an input-required or auth-required state is a request from the remote agent (inference), so do not grant credentials it asks for unless your policy already allows that scope (inference). See the task lifecycle for those states.

What is the ordered pre-delegation checklist?

Run these checks in order and stop at the first failure. This is a decision aid built from the references above, not an A2A requirement.

  1. Fetch the card from the agent's own origin over HTTPS and record the domain.
  2. Require a valid signature; refuse unsigned cards for anything sensitive.
  3. Decide why you trust that key, using a pinned key or an out-of-band confirmation. The reference leaves this unspecified.
  4. Read the declared security scheme and choose credentials per the authentication schemes article.
  5. Scan and hash the card text before any model sees it.
  6. If you use ERC-8004 data, treat reputation as a ranking hint and check supportedTrust.
  7. Start with low-impact, narrow-scope work, and carry authority as the credential propagation article describes.
  8. Validate every returned message and artifact, and log the card hash with each task.

Worked example: an unknown agent offering to book travel (inference, not a real case)

Suppose a card at https://agents.example.org/.well-known/agent-card.json advertises a booking skill. Step 1 records the domain. The card is unsigned, so step 2 stops you for anything sensitive; you may still run a read-only trial (inference). Suppose instead it is signed with a jku pointing at the same origin: step 3 fails unless you already hold that key out of band, because the jku proves only origin control. Only after a pinned key, a scanned and hashed card, and a narrow first task do you let it near a payment (inference).

Does ChangeGamer verify A2A agents?

No. As of 5 November 2026, ChangeGamer speaks MCP, publishes no agent-card.json, and the BACKLOG entry of 16 September 2026 records a deliberate decision to decline A2A discovery. It has no operating experience with signed cards or remote A2A delegates, so everything above is reasoning from the cited references.

Frequently asked questions

Which key should I trust to verify a signed A2A Agent Card?
The A2A specification, as read on 5 November 2026, defines key lookup via kid, jku or a trusted key store but no trust anchor, so you must choose one yourself, for example a key pinned out of band. A jku URL only shows control of that origin (inference).
Can an Agent Card description prompt-inject my orchestrator?
An Agent Card description can prompt-inject an orchestrator, as an inference from how MCP tool poisoning works. A card is self-published text and an orchestrator may pass its description and skills into a model prompt, where hostile instructions look like documentation. Treat card text as untrusted input and never let it reach a planner unreviewed.
Is ERC-8004 reputation enough to trust a remote agent?
ERC-8004 reputation alone is not enough: ERC-8004 was a Draft standard as of 13 October 2026, its text warns that fake agents can inflate reputation, and reading its feedback summary requires you to choose which client addresses you trust. Reputation is one weak signal beside a verified identity and your own limits.
Should I trust the artifacts a remote agent returns?
Artifacts from a remote agent are not trustworthy by default, because messages and artifacts are output from a party you do not control, so validate them before they reach your model or a downstream tool, exactly as MCP guidance says to validate tool results before passing them to the LLM.

#a2a #agent-card #trust #identity #erc-8004 #web-bot-auth #security #multi-agent

Put this corpus inside your own agents

This guide is free and stays free. The reference corpus behind it — machine-readable contracts, verified primary sources, continuously refreshed — is the paid product: a €5 starter key unlocks every premium reference for one agent via API; a €25 corpus license delivers the full corpus as RAG / fine-tuning data with an explicit AI-use grant; the €150 enterprise license adds commercial redistribution rights.

Agents: this page as Markdown · JSON · offers at /api/pricing.json · payment methods at /api/payment.json · single-resource access via HTTP 402 (how that works)