The underwriter u-uw-w1 has decided refer_to_inspection on SUB-1004: the application says the roof of PROP-2207 is 9 years old, the provider's data says 22, and someone has to look. The insurer does not employ roof inspectors. It works with an inspection firm (synthetic, like everything in the example), and that firm runs its own agent that takes inspection requests, finds an inspector and a time window, and confirms a booking.
The underwriting agent is asked to book the inspection. It has the delegated token from Agents, issued for the insurer's tool server. The quickest working integration is obvious: send that token, or the underwriter's own token, to the inspection firm's agent, and let it figure out who is asking.
That would be a mistake, and this page is about why and what to send instead. The inspection agent belongs to another organization, with its own identity provider, its own policy, its own audit trail and no reason to accept a token issued for the insurer's own services. Every earlier question comes back at once: who is calling, on whose authority, for what, and how anyone later reconstructs it across two companies' logs.
Agent-to-agent, in plain words#
Agent-to-agent (A2A) communication is one agent asking another agent to do work, where the second agent reasons and acts on its own side rather than executing one fixed function. Tiny example: the underwriting agent sends "book a roof inspection for this property, earliest window" to the inspection agent; the inspection agent checks inspector calendars and replies later with a booking.
There is also a protocol with that name. Standard (A2A protocol, specification 1.0.0, read 2026-11-18): A2A defines how agents publish what they can do, exchange messages and track tasks across organizations; its own documentation calls MCP "vertical" (an agent to its tools) and A2A "horizontal" (agents to other agents across team or organization boundaries). Messages, tasks, streaming and the protocol's state machine are taught on a2a.sammuthu.com. This page keeps to the auth-centred part: identities, credentials, decisions and records.
Before AI. Business-to-business integration has always looked like this: a partner API, a client credential or certificate from onboarding, the partner deciding what your client may do, and both sides logging the calls. An agent on the other end does not change that structure. It adds discretion on the other side, which makes authorization and audit matter more.
Nothing in agent-to-agent trust requires a central orchestrator. Some systems have one coordinating agent; many have peers that call each other directly, as here. The controls on this page sit at each caller and each recipient, so they work in either shape.
Two identities on the wire, again#
Agents separated the agent's own identity from the authority it carries for a person. Both separations survive the organizational boundary, and both get harder.
The first is the calling agent's own identity: the inspection agent must know the request comes from the insurer's underwriting agent, not from someone who found the endpoint. That is ordinary client authentication, done the way the inspection firm decides.
The second is the authority behind the request: the booking follows from the underwriter's decision on SUB-1004. Forwarded authority is the question of how a person's or an upstream principal's authority reaches a recipient further down a chain. The answer on this site is fixed: never by forwarding the token you received. A token issued for one audience is presented only to that audience. To carry authority to another recipient, the caller obtains a new token issued for that recipient, with narrower scope, and the recipient's authorization server decides whether to issue it. Token exchange mechanics are on OAuth and OIDC; the same rule for MCP servers, where the specification forbids token passthrough, is on MCP.
Common confusion. "We are sending the user's identity so the other agent can check permissions" usually means "we are forwarding the user's bearer token". The recipient then holds a credential that works at every service that accepts that audience, and its logs show the user acting where the user never was. Send an assertion issued for the recipient, or nothing.
The smallest primitive: a nested chain and an audience check#
Before crossing an organization, look at a chain inside one. When the underwriting agent's request reaches the insurer's assessment service, and the assessment service needs its own token to continue, the assessment service exchanges again. The result keeps the person as sub and nests the actors: the current actor outside, the earlier one inside. This is a delegation chain.
The snippet builds that second hop with the example's tokens.token_exchange, then tries three things the token service must refuse and checks where the second-hop token is accepted. A successful run proves the token service narrows per hop and binds each token to one audience; it does not prove anything about a real authorization server.
import agent
import demo_keys
import tokens
from clock import SimClock
clock = SimClock()
now = clock.now()
first = agent.delegated_token(clock)["exchange"]["response"]["access_token"] # aud: the tool server, act: the agent
svc = tokens.sign(tokens.make_claims("svc-assessment", aud=tokens.STS_AUDIENCE, now=now, scope="uw.read",
principal_type="service", client_id="svc-assessment"))
hop2 = tokens.token_exchange(first, svc, tokens.ASSESSMENT_AUD, "uw.read", now=now)
print("hop 2 act chain:", hop2["claims"]["act"], "| aud:", hop2["claims"]["aud"], "| scope:", hop2["claims"]["scope"])
for label, aud, scope in (("widen at hop 2", tokens.ASSESSMENT_AUD, "uw.read uw.decide"),
("LLM gateway", tokens.LLM_GW_AUD, "uw.read"),
("external agent", "https://agents.inspections.example", "uw.read")):
r = tokens.token_exchange(first, svc, aud, scope, now=now)
print(f"{label:<15} {r['status']} {r['error']}: {r['error_description']}")
tok = hop2["response"]["access_token"]
for label, aud in (("at assessment service", tokens.ASSESSMENT_AUD), ("at quote API", tokens.API_AUD)):
v = tokens.verify(tok, keyset=demo_keys.keyset(), expected_issuer=tokens.ISSUER, expected_audience=aud, now=now)
print(f"hop-2 token {label:<22} valid={v['valid']} first_failed={v['first_failed']}")
Run in a scratch copy of examples/uw-auth on 2026-11-18. The agent here is a scripted stand-in, so these results show how the access controls work, not how good any model is; the tokens are demo tokens, so use a maintained library and a real authorization server in production.
hop 2 act chain: {'sub': 'svc-assessment', 'act': {'sub': 'wl-underwriting-agent'}} | aud: https://assessment-svc.internal.example | scope: uw.read
widen at hop 2 400 invalid_scope: requested scope uw.decide is wider than the subject token's scope
LLM gateway 400 invalid_target: no token can be issued for audience https://llm-gw.internal.example
external agent 400 invalid_target: no token can be issued for audience https://agents.inspections.example
hop-2 token at assessment service valid=True first_failed=None
hop-2 token at quote API valid=False first_failed=aud
Four things to notice. The chain records both actors, and Standard (RFC 8693, read 2026-11-18): only the outermost act is used for access control; nested ones are history. The second hop cannot widen: it is checked against the token it came from. The second-hop token fails at the quote API at the audience check, so a leak at one hop does not open the others.
The fourth line is the one this page is about. The insurer's token service refuses to issue a token for https://agents.inspections.example, and it is right to: a token it minted for that audience would be a claim about the inspection firm's permissions made by the wrong party. Crossing the boundary needs the other side's cooperation.
The lab's "agent to agent" view shows the same nested chain and a receiving-service select that applies the audience check.
| Field of the hop-2 token | Value | What the recipient does with it |
|---|---|---|
| sub | u-uw-w1 | the person the work is for; never the principal at this hop |
| act.sub (outermost) | svc-assessment | the current actor; the only actor used for access control |
| act.act.sub (nested) | wl-underwriting-agent | an earlier actor; informational, for audit |
| aud | https://assessment-svc.internal.example | accepted only there; the quote API refuses it at aud |
| scope | uw.read | cannot be widened at this hop (uw.decide: invalid_scope) |
Crossing the boundary: federation, not forwarding#
Cross-organization federation is an arrangement in which one organization's authorization server accepts identity or authorization information issued by another's, under rules both agreed, and then issues its own token. The inspection firm's authorization server stays the only issuer of tokens its agent accepts. What changes is what it will accept as input.
Three shapes are common, from simplest to most capable.
Client credentials at the partner. The inspection firm registers the insurer's underwriting agent as a client and gives it credentials, ideally a private key or a client certificate rather than a shared secret. The agent obtains a token from the firm's authorization server with a scope such as booking inspections. The firm knows which organization and which agent is calling; it does not learn which underwriter decided, and does not need to, if the insurer's own records hold that.
Federated workload identity. Instead of a stored credential at the partner, the firm's authorization server trusts the insurer's workload identity issuer for named agents, so the agent proves itself with an assertion its own platform issued. This removes a long-lived secret from the integration. The pattern is the same as CI-to-cloud federation on Cloud IAM.
Chained authorization across domains. When the recipient must know the person or the upstream task, the insurer's authorization server issues an assertion intended for the firm's authorization server, which exchanges it for its own access token. Standard (IETF draft, read 2026-11-18): "OAuth Identity and Authorization Chaining Across Domains" (draft-ietf-oauth-identity-chaining-17, July 2026) describes this; it is an Internet-Draft in the RFC Editor queue, not an RFC. This site's recommendation: treat it as the direction of travel and the protocol details as subject to change; the principle it encodes (each domain issues its own tokens, from assertions it chose to trust) does not depend on the draft.
What the underwriting agent presents to the inspection agent#
Here is the design for the booking, written for this page; the example stops at the insurer's boundary.
| Question | What the underwriting agent presents | What it never presents |
|---|---|---|
| Who is calling? | its own identity: an assertion for wl-underwriting-agent from the insurer's workload identity issuer, or the client credential the firm issued | the underwriter's token or session |
| On whose authority? | a reference to the human decision: decided by an underwriter, refer_to_inspection, and the insurer's own task id | u-uw-w1's identifier, unless the contract requires a named requester |
| What may it ask for? | a token from the firm's authorization server with one scope, such as booking an inspection, valid for minutes | a broad partner scope, or the insurer's uw.* scopes |
| For which audience? | the inspection agent's endpoint, as the firm's authorization server sets it | https://mcp.uw.insurer.example or any insurer audience |
| About what? | the property id PROP-2207, the access window, the inspection type | the submission, the broker, the roof evidence, the recommendation |
The last row is data minimization, an authorization decision on the insurer's side: the booking needs a property and a window, not the underwriting file.
The booking is also a side effect with a cost. The underwriter's decision is the authority for exactly one booking for PROP-2207. This site's recommendation: the agent application, not the model, turns the human decision into a booking task with a one-booking limit and an expiry, and the agent's request carries that task's id. A second booking request under the same decision is refused by the insurer's own policy before it leaves.
Diagram: Booking a roof inspection across two organizations · every token stays in the domain that issued it
Read left to right. On the insurer's side, the underwriter's decision becomes a booking task with a one-booking limit, and the underwriting agent proves its own identity. Nothing the insurer's token service issues crosses the boundary: it refuses the partner's audience. On the inspection firm's side, the firm's authorization server accepts an assertion or client credential it agreed to trust and issues its own short, narrow token. The inspection agent authenticates the request, authorizes it per caller and per task, and both sides log the shared task id.
- The insurer
- human decision refer_to_inspection: The underwriter decided an inspection is needed for SUB-1004. That decision is the authority for one booking.
- booking task: The agent application, not the model, turns the decision into a task: PROP-2207, one booking, a short expiry.
- agent's own identity: An assertion from the insurer's workload identity issuer, or the client credential the firm issued.
- The inspection firm (synthetic)
- firm's authorization server: Accepts the insurer's assertion or client credential under agreed rules and issues its own token.
- inspection agent: Checks the token against the scheme its card declares, then authorizes per caller and per task.
- both audit trails: Each side logs the insurer's task id and the A2A task id, with no token or secret.
Every token stays inside the domain that issued it; what crosses the boundary is an assertion the other side chose to trust and a task reference both sides log.
Discovery: an Agent Card is a claim#
How does the underwriting agent learn where the inspection agent lives and how to authenticate to it? A2A answers with an Agent Card: a JSON document the agent's provider publishes, describing the agent's identity, skills, endpoint and authentication requirements. Standard (A2A 1.0.0, read 2026-11-18): the card's conventional location is https://{server_domain}/.well-known/agent-card.json.
A card is a statement by whoever serves it: how the agent says it wants to be called. It does not prove the agent is who it says, or that its skills are safe.
Three checks turn a card into something you can act on. First, fetch it only over TLS from a domain you already decided to trust: the inspection firm's domain from the contract, not one found by search. Standard (A2A 1.0.0): "Production deployments MUST use encrypted communication", and clients "SHOULD verify the A2A Server's identity by validating its TLS certificate". Second, verify its signature if it has one. Standard (A2A 1.0.0, §8.4): Agent Cards "MAY be digitally signed using JSON Web Signature (JWS)"; the content "MUST be canonicalized using the JSON Canonicalization Scheme (JCS)" (RFC 8785) with the signatures field excluded; clients "SHOULD verify at least one signature before trusting an Agent Card", and "Expired or revoked keys MUST NOT be used for verification". Signing is optional in the specification, so whether to require it is your policy. Third, pin what you learned: record the card's signing key or hash at onboarding and alert when it changes.
This site's recommendation: for a cross-organization partner, require a signed card, verify it against a key exchanged at onboarding, and treat the card's skill list as a catalogue to review, never as a grant. A skill on a card says what the agent offers; whether your agent may use it is your policy, and whether your request is allowed is theirs.
Diagram: From Agent Card to a request your policy allows · three checks before trust
An Agent Card is a statement by whoever serves it. The caller fetches it only over TLS from the domain in the contract, verifies its JWS signature against the key exchanged at onboarding, and compares it with the pinned copy. Only then does it read the security schemes, which say what kind of credential to bring, never the credential itself. The skills on the card go through the caller's own outbound policy, and the recipient still authorizes each request.
- Is this card the partner's?
- fetch over TLS: The card comes from the domain named in the contract, at its well-known location, with the server certificate validated.
- verify signature: Card signing is optional in the specification (MAY); requiring it for partners is your policy.
- compare with pin: A new endpoint, scheme or key waits for a person's review.
- What may we send?
- read security schemes: One of five types: API key, HTTP auth, OAuth 2.0, OpenID Connect, mTLS. Credentials are obtained out of band.
- outbound policy on skills: Your agent may use only the skills you reviewed and allowed for this partner.
- recipient authorizes: The partner decides on each request and hides what the caller may not see.
The diagram puts the three trust checks before anything on the card is used. The important observation is the order: the security schemes and skills are read only after the card is known to be the partner's.
Security schemes: how the card says to authenticate#
A security scheme is the card's declaration of an accepted way to authenticate. Standard (A2A 1.0.0, §4.5, read 2026-11-18): SecurityScheme is "a discriminated union type based on the OpenAPI 3.2 Security Scheme Object", with exactly one of five types set. The middle column paraphrases each type; the field details of each object are on the specification page:
| Scheme type in the specification | What the caller presents | Fits the booking when |
|---|---|---|
APIKeySecurityScheme | an API key | a low-risk partner endpoint and a key restricted to it |
HTTPAuthSecurityScheme | credentials under an HTTP authentication scheme | tokens come from an agreed issuer by other means |
OAuth2SecurityScheme | an OAuth access token; the flow objects defined include authorization code, client credentials and device code | the usual choice: the firm's authorization server issues scoped tokens |
OpenIdConnectSecurityScheme | a token from an OpenID Connect provider | the caller is a person's client, not a workload |
MutualTlsSecurityScheme | a client certificate in the TLS handshake ("mTLS authentication") | the partnership already runs a private PKI |
The card's field that lists the schemes is securitySchemes. The field that says which are required is named securityRequirements in the AgentCard definition (§4.4.1), while two other sections (§3.1.11 and §13.3) refer to it as AgentCard.security. That inconsistency is in the specification as read on 2026-11-18; check the current text and your library before relying on either name.
Two rules hold whatever the scheme. Standard (A2A 1.0.0, §7.3 and §7.4): "The client obtains the necessary credentials through an out-of-band process", and the server "MUST authenticate every incoming request". The card never contains a credential; it says which kind to bring. And the recipient decides authorization after authentication: Standard (A2A 1.0.0, §7.5 and §13): authorization is implementation-specific and "MAY consider" skills, actions, data access policies and scopes; implementations "MUST ensure appropriate scope limitation based on the authenticated caller's authorization boundaries"; "Authorization checks MUST occur before any database queries"; and servers "MUST NOT reveal the existence of resources the client is not authorized to access". That last rule is the same 404 the quote service returns for another tenant's quote.
The recipient decides, per task#
The inspection agent is a principal with its own policy, and caller authorization at the recipient is its job. Authenticating the insurer's agent answers "who"; it then has to decide whether this caller may book this kind of inspection, for this property, now, and how many times. That is the same subject, action, resource and context question as on Authorization, asked by a different organization.
Task-scoped permissions are permissions that exist only for one A2A task: the token the firm issues can name the task, and the firm's policy can refuse a second booking under the same task or a booking for a different property. The pattern mirrors the task token on Agents, on the other side of the boundary.
A2A has one feature that looks like authorization and is not. A task can enter the state TASK_STATE_AUTH_REQUIRED, which "Indicates that authentication is required to proceed". Standard (A2A 1.0.0, §7.6): agents "MUST arrange to receive credentials via an out-of-band means, unless an in-band mechanism has been negotiated"; credentials "SHOULD be bound to the agent which originated the request"; and agents "MUST NOT treat the TASK_STATE_AUTH_REQUIRED state transition, by itself, as authorization for any particular operation". In other words, the other agent asking for more credentials is a request, not a decision. Your side still decides whether to provide them and for what.
Recipient capabilities cut the other way: what the inspection agent can do on its own side is bounded by its own platform, and the insurer should assume nothing about it. A callback from the inspection agent (to report the booking) is a separate inbound integration with its own authentication and one narrow permission, such as updating the inspection status of PROP-2207. Callback verification is on SaaS and webhooks.
Message signatures and transport security are different promises#
TLS protects a connection: in transit, nobody in the middle can read or change the bytes, and the client knows which server it reached. When the connection ends, so does the protection. A message that is stored, queued or examined months later carries no proof of who wrote it.
A message signature is a signature over the message content itself, made with the sender's key, that anyone with the public key can verify later, wherever the message has been. Tiny example: the booking request is signed by the insurer's agent key; the inspection firm stores the signed request with the booking, and in a dispute either side can show who asked for what.
Standard (A2A 1.0.0, read 2026-11-18): the specification read here requires encrypted transport and defines JWS signing for Agent Cards; it defines no signature over individual messages, and push notifications authenticate with credentials in the request, not a payload signature. So in A2A as read today, per-message integrity beyond the connection is something you add.
This site's recommendation: for cross-organization requests with commercial consequences (a booking that costs money), sign the request content as a JWS with a key registered at onboarding and store the signed form on both sides. Use a maintained JOSE library. For internal agent calls inside one trust domain, mTLS plus authenticated tokens and good audit records are usually enough.
Distributed audit and correlation#
When the booking goes wrong (two inspections are booked), the investigation spans two organizations, and neither can read the other's logs. What makes reconstruction possible is agreed in advance: shared identifiers in every message, logged on both sides.
| Identifier | Who creates it | Who logs it |
|---|---|---|
The insurer's task id for the booking (derived from run-7f3a and the human decision) | the insurer's agent application | the insurer; sent in the request so the firm can log it |
| The A2A task id | the inspection agent | both sides |
| A trace id per inbound request | the side that receives the request | each side, for its own diagnostics |
The calling identity and the token's jti | the firm's authorization server | the firm; the insurer logs which credential it used |
Each side's records follow the same rules as on Audit: who acted, on whose authority, what was decided under which policy version, with no token or secret in the record. Standard (A2A 1.0.0, §13): agents "SHOULD log security-relevant events (authentication failures, authorization denials, suspicious requests)", and logs "MUST NOT include sensitive information (credentials, personal data) unless required and properly protected". Tracing a request across agents as an observability practice is on observe.sammuthu.com.
What goes wrong, and which control catches it#
| Failure | What happens | Control |
|---|---|---|
| Forwarding the delegated token to the partner | the partner holds a credential for the insurer's tool server; a leak there is a breach here | exchange per audience; the insurer's token service refuses foreign audiences (invalid_target) |
| Trusting a card found by search | a look-alike card points to an attacker's endpoint and asks for an API key | fetch from a contracted domain over TLS; require a signed card |
| Treating auth-required as permission | the other agent asks for more credentials and the caller sends the user's | out-of-band credentials, bound to the originating agent; your policy decides |
| Using a nested actor for access control | an earlier actor's identity is used to grant at a later hop | only the outermost act counts (RFC 8693) |
| No shared task id | each side's logs are complete and cannot be joined | agree identifiers in the integration contract |
| Sending the underwriting file | the partner receives data it never needed | minimization as an authorization rule on the outbound request |
What this is not. This page does not teach A2A messages, task states, streaming or push notification mechanics (a2a.sammuthu.com), how an MCP server authorizes tool calls (MCP), or the agent's own delegation and approval design (Agents). It is about trust between agents: identity, authority, discovery, authorization and audit across the boundary.
Architecture choice: how much cross-agent trust machinery#
| Situation | Simplest credible choice | Grow when | Alternatives |
|---|---|---|---|
| Agents inside one organization | workload identity (mTLS or signed workload tokens) plus token exchange per hop, nested act | other teams run their own authorization servers | a service mesh with per-service policy |
| One trusted partner, workload-to-workload | client credentials at the partner's authorization server, with a private key or certificate, one narrow scope | the partner must know the person or the upstream task | mTLS scheme with a private PKI |
| Partner needs the person or the task | chained authorization: the partner's server accepts your assertion and issues its own token | many partners | per-partner custom assertions |
| Many partners, discovery by card | signed Agent Cards verified against onboarding keys; a reviewed catalogue of allowed skills | public, open-ended discovery | a registry run by your organization |
| Requests with commercial consequence | add JWS-signed request content, stored on both sides | disputes, regulators | contractual logging obligations only |
In a coding agent. A coding agent that asks a code-review bot or a dependency-update bot for work is in the same position: each bot is a separate app installation with its own identity and its own repository permissions, and none should receive the agent's token. Each acts through its own installation, and the pull request and its review history are the shared record. Depth on Coding agents.
Security notes#
- Never forward a token across a boundary; obtain one issued for the recipient by the recipient's authorization server.
- A card is a claim: fetch over TLS from a contracted domain, verify its signature, pin the key.
- Skills on a card are offers, not permissions; your outbound policy and the recipient's inbound policy both decide.
TASK_STATE_AUTH_REQUIREDis a request for credentials, never an authorization.- Send the minimum data the recipient's task needs; decide that on your side before the request leaves.
- Agree shared task identifiers and log them on both sides, without tokens or secrets.
Monday checklist#
- List every agent or bot your agents call outside your trust domain, and what credential each call carries. Any forwarded user token is the first fix.
- For each external agent, write down where its card comes from, whether it is signed, and which key you trust for it.
- Confirm your token service refuses audiences it does not serve (an exchange for a partner's URL must fail).
- Pick one cross-organization call and try to reconstruct it from your logs alone: can you name the partner's task id?
- Review the data your agents send to each partner against what the partner's task needs.
Exercises#
Exercise 1. The inspection firm's card lists a skill "cancel any booking". Your agent only books. What do you do with that skill?
AnswerNothing in the card grants it; exclude it in your outbound policy
Leave it out of your agent's allowed skill list for this partner, so the agent application refuses to send it whatever the model proposes. Ask the firm to issue your client a token whose scope cannot cancel bookings it did not create.
Exercise 2. A developer proposes passing the underwriter's ID token to the inspection agent "so they know a real person approved". What do you offer instead?
AnswerA reference to the human decision, or an assertion issued for the partner
Send the insurer's task id that references the recorded human_decision, and keep the person's identity in the insurer's audit trail. If the contract needs a named requester, the insurer's authorization server issues an assertion intended for the firm's authorization server.
Exercise 3. The firm's agent replies with TASK_STATE_AUTH_REQUIRED and asks for "the insurer's API key for the property data service". What should happen?
AnswerRefuse; the state is not authorization and that credential is not yours to share
The state transition is not a permission, and the property data service's key belongs to the insurer's own services. Your agent application refuses, records the request as a security event, and a person reviews the integration.
Advanced perspective#
The partner as confused deputyA recipient that acts with its own broad rights on your behalf
Cross-organization chains invert the confused-deputy risk. The inspection agent may hold broad rights in its own systems (every inspector's calendar, every customer's address). If it acts on any well-formed request from any authenticated partner, a partner can ask it to do things the partner could not do directly, such as look up another insurer's bookings. The defense belongs to the recipient: decide per caller and per task, return "not found" for resources outside the caller's boundary (the A2A specification's own MUST), and never let an authenticated partner inherit the recipient's reach. As the caller, you can only check that the partner's contract and its tokens' scopes say this.
Orchestrator or peers: where the policy livesCentral coordination simplifies audit and concentrates authority
A central orchestrator that calls every other agent gives one place to log, one place to enforce outbound policy and one place to stop a run. It also becomes the most powerful principal in the system: if it holds broad credentials, compromising it reaches everything. Peer-to-peer designs spread authority and make each agent enforce its own inbound policy, at the cost of correlation work. Neither is required by A2A. The controls on this page assume no orchestrator: each caller narrows what it sends, each recipient authorizes what it receives, and shared ids join the records. If you add an orchestrator, give it delegated, task-scoped tokens like any other agent, never a superset of everyone's rights.
Agent Cards as a supply-chain artifactChanges to a trusted card deserve the review a dependency update gets
Once your agent trusts a partner's card, a change to that card changes your system: a new endpoint, a new scheme, a new skill. Treat it like a dependency. Store the verified card at onboarding with its signature and key id; on each fetch compare, and on any change to endpoint, schemes or signing key, stop using the new card until a person reviews it. Multiple signatures on a card are allowed for key rotation (A2A 1.0.0, §8.4.3), which gives partners a way to rotate without breaking you, if you check for the new key's arrival before the old one goes. The overlap logic is the same as signing-key rotation on Operations.
What is standard, what is patternKeep the A2A specification, OAuth drafts and your design apart
Standard: A2A 1.0.0 defines Agent Cards, the five security scheme types, optional JWS card signatures, encrypted transport, authentication of every request and an in-task authorization state; it leaves authorization models to implementations. RFC 8693 defines token exchange and the act claim. Draft: cross-domain identity and authorization chaining is an Internet-Draft (revision 17). Pattern: client credentials at a partner, federated workload identity, signed request content, shared task ids and outbound data minimization are practices, not requirements of any of these documents. This site's recommendation: the specific choices in the booking table. Writing these four labels into an integration design document prevents the most common review argument: whether something is "required by A2A".
In one breath#
An agent calling another organization's agent presents its own identity and authority issued for that recipient by the recipient's authorization server, never a token it received. The recipient decides per caller and per task, hides what the caller may not see, and treats a request for more credentials as a request. An Agent Card is a claim until it is fetched from a trusted domain and its signature checked; its skills are offers, not grants. TLS protects the connection, a signature protects the message after it lands, and shared task ids are what let two audit trails tell one story.
The underwriting agent has now crossed the insurer's boundary twice in this series: into the inspection firm here, and out to tools on MCP. The next page turns to the agents that change the insurer's own code. Coding agents and CI applies the same separation (the agent's identity, the person's authority, the irreversible step that stays with a person) to repositories, pipelines and the path to production.