06-reference/research

a2a registry discovery signed agent cards

2026-11-09·research-brief·source: deep-research·by Ray Data Co (deep-research synthesis)
a2aagent-identityagent-registrysigned-agent-cardsorganizational-intelligence

A2A Declines to Define a Registry API, Makes Card Signing Optional, and No Vendor Documents Verifying It

The question

Does the A2A protocol specification (v1.2 or later) define a registry/discovery API or cryptographically signed Agent Cards, and have Microsoft, Google, or Salesforce shipped signed-card verification in a production agent product?

Context: this is open follow-up #1 from [[2026-09-13-cross-substrate-agent-identity-registry-standard]], narrowed to the verification mechanism. That parent brief already closed the broader "is a cross-substrate agent-state standard emerging" question (answer: no), so this brief only resolves the two mechanisms and the shipped-product status.

Premise correction up front: there is no A2A v1.2. The question was filed 2026-09-16 carrying a version number from the vault that was wrong at the time. See the first bullet below.

What we already know (from the vault)

What the web says

Version, pinned today (evidence tier: primary repository metadata, GitHub API on a2aproject/A2A, fetched 2026-11-09). There is no v1.2 and no v1.1 stable. Latest stable release is v1.0.1, published 2026-05-28; v1.0.0 published 2026-03-12; v1.1.0-rc is a release candidate tagged 2026-10-29, eleven days before today. The spec on main still advertises "Latest Released Version 1.0.0" in its own header. The signatures field was added to the Agent Card in v0.3.0 (2025-07-30), per that release's notes.

(a) Registry / discovery API: the spec explicitly declines to specify one (evidence tier: spec text). Section 8.2 "Discovery Mechanisms" names exactly three ways a client finds a card: the well-known URI https://{server_domain}/.well-known/agent-card.json, "Registries/Catalogs: Querying curated catalogs of agents," and direct configuration. Publishing a card is mandatory ("A2A Servers MUST make an Agent Card available," §8.1), but the registry is named as a deployment pattern with no interface. The companion normative-adjacent guide docs/topics/agent-discovery.md states it outright: "The current A2A specification does not prescribe a standard API for curated registries." That sentence is present unchanged in v1.0.1, in v1.1.0-rc, and on main. The same guide adds that "the A2A community explores standardizing registry interactions or advanced discovery protocols," i.e. future work. A keyword sweep of the full specification for "registr" or "catalog" returns only that one discovery bullet, the IANA registration templates (§14), and a legacy-name appendix. There are no registry operations in the protocol's method set. So: not normative, not left silently to implementations, but explicitly declined and flagged as open.

(b) Signed Agent Cards: the mechanism exists, it is OPTIONAL, and verification is specified but only SHOULD-triggered (evidence tier: spec text). Section 8.4 in v1.0.x, renumbered to 8.3 in v1.1.0-rc, reads: "Agent Cards MAY be digitally signed using JSON Web Signature (JWS) as defined in RFC 7515." The construction is tight where it exists: canonicalization MUST use the JSON Canonicalization Scheme (RFC 8785), the signatures field MUST be excluded from the signed payload, and the JWS protected header MUST carry alg, kid and SHOULD carry typ: JOSE, with an optional jku pointing at a JSON Web Key Set. Verification is specified as a six-step MUST for "clients verifying Agent Card signatures," but whether a client verifies at all is governed by one line in Security Considerations: "Clients SHOULD verify at least one signature before trusting an Agent Card." SHOULD, not MUST. Multiple signatures MAY be present for key rotation, and expired or revoked keys MUST NOT be used.

The signature proves integrity, not identity (evidence tier: spec text read against third-party analysis). Nothing in §8.4/§8.3 binds a signing key to an organization. A client that follows the spec to the letter and fetches the public key from the jku named inside the card it is verifying has proved only that the card was not modified between signing and fetch. Third-party writeups converge on this reading, and a proposed verifiedIdentity field is reported as GitHub issue #1672 in a2aproject/A2A (third-party report, status unverified).

The reference SDK ships verification and leaves it off by default (evidence tier: primary source code). a2a-python pull request #581, "feat: Implement Agent Card Signing and Verification per Spec," merged 2025-12-12, adding src/a2a/utils/signing.py and _jcs.py with create_agent_card_signer and create_signature_verifier. But in client.py, client_factory.py and card_resolver.py the parameter is signature_verifier: Callable[[AgentCard], None] | None = None, and card_resolver.py only invokes it inside if signature_verifier:. The ecosystem default is "fetch the card, do not check the signature." Any vendor that built on this SDK and did not pass a verifier is not verifying.

Microsoft: A2A is GA, signed-card verification is absent from the docs (evidence tier: vendor documentation). On the server side, Microsoft Foundry Agent Service's "Enable incoming A2A on a Foundry agent" states that "Foundry Agent Service supports generally available A2A protocol version 1.0 and preview version 0.3" and that "New integrations should target version 1.0." The card is authored by the operator as an agent_card object in a single PATCH call, and Foundry then "publishes an agent card." Across the full page there is no signatures field in any example and no mention of signing, JWS or JWKS. On the client side, Copilot Studio's "Connect to an agent over the Agent2Agent (A2A) protocol" says that after you enter the endpoint URL, "if your agent has a valid agent card on the standard .well-known URL, Copilot Studio automatically pulls the name and description." "Valid" there means parseable and reachable: the troubleshooting guidance covers a missing card, a card at a non-standard URL, or a communication failure. Zero mentions of signature, JWS or JWKS. A Microsoft Learn search API sweep for "A2A agent card" and "agent card signature" surfaced no Entra Agent ID, Agent 365 or Foundry page on card-signature verification. State: GA for the protocol, nothing documented for signature issuance or verification.

Google: the registry is GA, cards are admin-pasted, and the product is pinned behind the spec (evidence tier: vendor documentation). Gemini Enterprise's "Register and manage A2A agents" has the admin paste card contents into a console form: "In the Agent card JSON field, enter the agent card details in JSON format." That is an operator assertion, not a fetched-and-verified document. The same page states, flatly, that "Gemini Enterprise doesn't use the securitySchemes and security fields of your agent card to authenticate with your agent" — the product selectively ignores card contents. It also states that "Gemini Enterprise supports the A2A v0.3 streaming mechanism. If you use A2A v1.0.0 or later, then use the compatibility packages provided by the SDK" — the GA enterprise surface is on v0.3 semantics, two releases behind. Every signature mention on that page and on "Import and govern agents from Agent Registry" concerns OAuth 2.0 and OpenID Connect tokens (a Google-signed OIDC identity token for the Discovery Engine service agent; an Apigee VerifyJWT policy against a provider's JWKS) or TLS certificate authorities for the Agent Gateway. None of it is card-signature verification. State: registry GA, card-signature verification not documented.

Salesforce: orchestration is GA-adjacent, the producer half ships, and a gateway policy actively mutates cards (evidence tier: vendor documentation, except where marked). Winter '27 went generally available 2026-10-12 and the release announcement says "Agentforce's native Third-Party Orchestration extends Agentforce across any A2A-compliant ecosystem," with no per-feature availability label (Salesforce press release; feature-level GA inferred from the release-level statement, not stated). MuleSoft Agent Fabric / Agent Registry reached GA in January 2026 (Salesforce press release). In the documentation: the Agent Network project-file reference lists signatures as "JSON Web Signatures computed for this AgentCard," Required No — a field you populate on a card you publish. Anypoint Exchange release notes (July 2026) say "the v1.0 card supports the supportedInterfaces field for declaring transport bindings and optional card signatures," and the card-details page renders a "Signature indicator (shown only for signed cards)" — a presence badge, not a verification result. Manual registration states that "the system does not validate a connection before creating the agent." And the Omni/Flex Gateway "A2A v1 Agent Card Policy" rewrites the url field of each interface inside the card in flight so clients route through the gateway, with no documented re-signing and no caveat that this invalidates a detached JWS over the card. State: not documented, and structurally in tension with verification.

Convergences and contradictions

Synthesis for RDCO

RDCO is dormant per the founder's 2026-09-23 call and phData is the main bet, so the value here is corrective rather than commercial. The correction is this: "A2A-compliant" is a transport claim, and this brief establishes with spec text and vendor documentation that it carries no verified-identity guarantee at all. Three distinct things get conflated in vendor material, and they should be kept apart in any future vault note or phData-facing conversation: (1) the agent publishes a card, which is mandatory; (2) the card is signed, which is optional and which Salesforce exposes as a producer-side YAML field and an Exchange badge; (3) a consumer verifies that signature against a key bound to a real organization, which is specified only as a SHOULD, shipped off-by-default in the reference SDK, and documented by nobody. Treating (1) as evidence of (3) is the exact error the parent brief warned against when it separated "announced support" from "shipped and documented."

For portable-identity thinking, the practical conclusion is that card signatures are not the portable-identity layer, and should stop being modelled as a candidate for it. The parent brief concluded that identity is portable via OAuth 2.0 / OpenID Connect plus workload-identity federation while state is not. This brief tightens that: the token layer is where all three vendors actually put their cryptography. Google's A2A registration page spends its entire security section on OIDC identity tokens and Apigee JWKS validation; Microsoft's agent identity story is Entra tokens; Salesforce's trust story is Flex Gateway plus OAuth 2.0 plus manual admin registration. The Agent Card is metadata for discovery and routing, and in Gemini Enterprise it is literally pasted in by an administrator. A portable-identity design that leans on signed cards would be leaning on a mechanism the market has already routed around.

For the Organizational Intelligence governance layer, this is a concrete, citable example of a control that exists on paper and not in the runtime — which is exactly the class of gap the OI layer is supposed to surface. The Organization Platform / Org Map side is where a third-party agent gets recorded as a node with a provenance claim; the Intelligence Platform / IMA side is where that claim gets asserted in automated reasoning; OIP plus Pulse is where drift between the claim and reality should become visible. A2A supplies a near-perfect test case: an enterprise can hold a complete inventory of A2A agents in which every card is self-asserted, several are machine-synthesized from platform APIs rather than read from the agent, one gateway rewrites card fields in transit, and no signature is ever checked — and nothing in any vendor console will say so. If the OI layer models agents as inventory nodes, the field that matters is not "has a card" or even "card is signed" but "who verified this card, with which key, bound to which organization, and when" — and today the honest value for every vendor-registered agent is "nobody." A governance layer that records provenance as a tri-state (self-asserted / signed-but-unverified / verified-against-a-trust-anchor) will be describing the real world; one that records a boolean "registered" will be recording a vendor's marketing claim.

Watch triggers that would change this answer, each checkable cheaply: the signatures MAY in §8.4/§8.3 being promoted to a MUST, or the "Clients SHOULD verify" line becoming MUST, in A2A v1.1 stable or v1.2; signature_verifier acquiring a non-None default in a2a-python; GitHub issue #1672's verifiedIdentity field landing in the spec; or any one of the three vendors publishing a documented trust-anchor or JWKS-allowlist configuration for inbound cards. The last of those is the one that would matter commercially, because it is the point at which "A2A-compliant" starts meaning something a buyer can audit. Note also for terminology hygiene that "CAF" was retired as a name on 2026-08-10; the framing is Organizational Intelligence.

Why this is in the vault

This closes open follow-up #1 of [[2026-09-13-cross-substrate-agent-identity-registry-standard]] and corrects a factual error that brief propagated from [[2026-06-04-a2a-protocols-beyond-mcp-rdco]]: A2A's current stable release is v1.0.1 (2026-05-28), not v1.2. It also supplies the provenance-field design input for the Organizational Intelligence agent-inventory model — specifically that an agent node needs a tri-state verification provenance field rather than a registered/unregistered boolean, because no vendor registry today verifies the card it stores.

Open follow-ups

Related

Sources

Vault:

Spec text (primary, fetched to disk and read locally 2026-11-09):

Reference implementation (primary source code):

Vendor documentation (primary, fetched):

Vendor blog / press (announcement tier, not documentation):

Third-party (lower tier, claims marked in text):

Not reached / flagged: