Cross-Organization Collaboration: A2A in Multi-Vendor Stacks
How independent organizations run Agent2Agent (A2A) collaborations across vendor boundaries: opaque agents, signed Agent Cards, cross-org discovery, contractual delegation, and the governance patterns that keep multi-vendor agent stacks operable.
Published on • November 16, 2026
AI Assistant

Your agents will not live in your building. A logistics platform needs a customs agent operated by a broker in another country; a bank’s advisory agent needs to hand a mortgage task to a lender’s agent built on a different framework by a vendor that has never heard of your internal tool schema. The integration question is no longer “how do my microservices talk?” but “how do two organizations, with different vendors, different stacks, and different security postures, let their agents work together without merging their infrastructure?”
The Agent2Agent (A2A) protocol is designed for exactly this shape of problem. It is an open standard - now part of the Linux Foundation’s Agentic AI Foundation - for communication between opaque agentic applications: agents that collaborate without exposing their internal state, memory, or tools. In this tutorial you will learn how A2A makes cross-organization collaboration work in practice: the discovery contract, the delegation contract, the security contract, and the governance patterns multi-vendor stacks actually need.
Prerequisites
- Familiarity with the A2A basics: Agent Cards, tasks, and messages (see the repository for the specification)
- Two HTTP services you control (or two containers) to act as agents in different “organizations”
- Python 3.11+ with
pip install a2a-sdk httpxfor the examples - A working mental model of OAuth 2.0 / OpenID Connect at the level of “who issues tokens and who verifies them”
The Cross-Organization Problem, Stated Precisely
Single-team multi-agent systems cheat. They share a message bus, a database, an in-process object, or at least a monorepo. Cross-org collaboration removes every one of those cheats:
- No shared runtime. The other organization’s agent runs on their servers, in their cloud, behind their firewall.
- No shared framework. You are on LangGraph; they are on Google ADK or a hand-rolled stack. Neither will re-platform to match.
- No shared trust. You cannot simply “trust the payload.” Identity, accountability, and authorization must be explicit.
- No shared schema. Their internal tools, memory stores, and prompts are proprietary - and they are right to keep them that way.
A2A’s answer to all four is a deliberately thin protocol built on web primitives: HTTPS endpoints, JSON-RPC 2.0, JSON manifests, and standard authentication schemes. The protocol standardizes the conversation, not the cognition.
Pillar 1: Discovery via the Agent Card
The unit of cross-org discovery is the Agent Card - a self-describing JSON manifest every A2A server MUST publish at a well-known URL:
GET https://agent.vendor-b.example/.well-known/agent-card.json
A minimal card that a partner organization can act on:
{
"name": "Freight Quote Agent",
"description": "Computes freight quotes across modes for B2B shippers",
"version": "1.2.0",
"url": "https://agent.vendor-b.example/rpc",
"preferredInterface": "jsonrpc-1.0",
"protocolVersion": "1.0",
"capabilities": {
"streaming": true,
"pushNotifications": true,
"extendedAgentCard": true
},
"skills": [
{
"id": "quote-ocean",
"name": "Ocean Freight Quote",
"description": "Returns a quoted price for an ocean shipment",
"inputModes": ["text"],
"outputModes": ["text"]
}
],
"securitySchemes": {
"partnerOAuth": {
"oauth2SecurityScheme": {
"flows": {
"clientCredentials": {
"tokenUrl": "https://auth.vendor-b.example/oauth/token",
"scopes": {"quote:write": "Create quotes"}
}
}
}
}
},
"security": [{"partnerOAuth": ["quote:write"]}]
}
Three properties make this work across organizations:
- It is public and cacheable. Discovery requires no prior relationship. Your orchestrator can resolve a new partner’s capabilities at runtime, with HTTP caching (
ETag,Cache-Control) keeping it cheap. - It declares the security contract up front.
securitySchemesandsecuritytell you how to authenticate before you send a single request - no surprise 401s, no wiki pages. - It declares skills, not internals. The partner advertises what it can do (
quote-ocean), never how: no prompts, no tool implementations, no model choice. This is A2A’s opacity principle - collaboration without intellectual-property leakage.
For a deeper field-by-field walkthrough of the card, see our companion post on publishing A2A Agent Cards.
Extended cards: public discovery, private contract
When the public card is a marketing surface and the full contract should require a relationship, enable capabilities.extendedAgentCard: true. The partner authenticates using a declared scheme and fetches the extended card with GetExtendedAgentCard:
{"jsonrpc": "2.0", "id": 1, "method": "GetExtendedAgentCard", "params": {}}
The extended card can carry additional skills, internal endpoints, or stricter security requirements. Typical multi-vendor practice: the public card lists skills any stranger may see; the extended card lists the skills available to contracted partners.
Pillar 2: Delegation via Tasks
Discovery answers “who can help.” Delegation answers “do the work.” In A2A, work is delegated as a Task - a durable object with an ID, a state machine, and artifacts - not as a bare request/response.
A client in organization A delegates to an agent in organization B over JSON-RPC 2.0:
import httpx
async def delegate_quote(base_url: str, token: str) -> dict:
payload = {
"jsonrpc": "2.0",
"id": 1,
"method": "SendMessage",
"params": {
"message": {
"role": "ROLE_USER",
"parts": [
{"type": "text", "text": "Quote 2x40ft Shanghai to Rotterdam, ready 12-01"}
]
},
"configuration": {"acceptedOutputModes": ["text"]},
},
}
async with httpx.AsyncClient(timeout=60) as client:
r = await client.post(
f"{base_url}/rpc",
json=payload,
headers={"Authorization": f"Bearer {token}"},
)
r.raise_for_status()
return r.json()["result"]["task"]
The result is a task in TASK_STATE_SUBMITTED or TASK_STATE_WORKING, not the answer itself. Three task-lifecycle behaviors matter specifically for cross-org work:
- Long-running is normal. A quote that takes 90 seconds, or a compliance review that takes a day, is a first-class use case. You poll with
GetTask, stream withSendStreamingMessage, or register a webhook via push notification configs (CreateTaskPushNotificationConfig) - whichever fits your network topology. Cross-org networks often forbid long-lived inbound connections, which makes polling the default and push the optimization. - Multi-turn happens across the boundary. The partner’s agent may respond
TASK_STATE_INPUT_REQUIRED- “which incoterm?” - and your client continues the same task by threadingtaskIdandcontextIdinto the follow-up message. Clarification never leaks into a new, disconnected request. - Cancellation is protocol-level.
CancelTaskis the polite way to end delegated work when the business process aborts, giving the partner a chance to release reserved resources.
{"jsonrpc": "2.0", "id": 7, "method": "CancelTask", "params": {"id": "task-42"}}
Pillar 3: The Security Contract
Cross-org traffic is internet traffic between parties that do not share a security team. A2A deliberately does not invent new security machinery - the spec treats agents as “standard enterprise applications, relying on established web security practices”:
- Transport: HTTPS is mandatory in production; clients SHOULD verify the server’s TLS certificate against trusted CAs.
- Scheme negotiation: the server declares
securitySchemes(API key, HTTP bearer, OAuth 2.0, OpenID Connect, mTLS) in the card; the client acquires credentials out-of-band (the OAuth client-credentials flow is the multi-vendor default) and presents them in every request. - Server-side authorization: once authenticated, the server authorizes per its own policies - by skill, by action, by scope. Identity handling lives at the protocol layer, not in A2A message semantics.
- In-task authorization: if the partner’s agent needs your authorization mid-task (say, an OAuth token to call an API on your side), it transitions the task to
TASK_STATE_AUTH_REQUIREDand passes the credential request back to you as a normal task update.
Task: submitted -> working -> auth-required -> working -> completed
^ your client supplies the credential
This is the pattern that makes genuinely cross-org workflows possible: authorization is negotiated inside the task, not assumed at connection time.
Pillar 4: Governance for Multi-Vendor Stacks
Protocol compliance keeps agents talking; governance keeps the collaboration operable after the pilot. Four patterns cover most of it:
1. Version the contract, not just the code
Cards carry a version field, and A2A defines versioning responsibilities for both sides: clients must tolerate additive changes (new skills, new optional fields), servers must not break existing consumers within a major version. Treat a partner card bump as a contract change - review it in CI like any other dependency update:
def check_partner_card(old: dict, new: dict) -> list[str]:
warnings = []
if old.get("version") != new.get("version"):
warnings.append(f"card version changed: {old['version']} -> {new['version']}")
old_skills = {s["id"] for s in old.get("skills", [])}
new_skills = {s["id"] for s in new.get("skills", [])}
for removed in old_skills - new_skills:
warnings.append(f"REMOVED skill: {removed}")
return warnings
A removed skill is a breaking change. A new skill is not. Diffing the card is the cross-org equivalent of diffing an API schema.
2. Scope credentials per partner and per skill
One long-lived API key shared across all partners is how cross-org incidents start. Issue per-partner OAuth clients, request only the scopes the workflow needs (quote:write, not *), and rotate on a schedule both parties agreed to.
3. Keep an audit trail keyed to tasks
Because every unit of delegated work is a Task with a stable ID, cross-org accountability becomes straightforward: log taskId, contextId, partner identity, state transitions, and artifact hashes on both sides. When a dispute arises (“did we send the shipment data?”), both organizations can reconcile against the same identifiers.
4. Degrade deliberately
Your orchestrator should treat the partner directory as live data: if a card fetch fails or a partner’s agent reports TASK_STATE_FAILED repeatedly, route around it. A2A gives you discovery, not availability - your routing layer owns the fallback:
async def pick_quote_partner(directory: list[dict], mode: str) -> dict | None:
for entry in directory:
try:
card = await fetch_card(entry["base_url"])
except Exception:
continue
if any(s["id"] == f"quote-{mode}" for s in card.get("skills", [])):
return entry
return None
Putting It All Together
A full cross-org loop looks like this:
- Onboard (once): exchange base URLs, agree on auth scheme, exchange OAuth client credentials out-of-band.
- Discover (cached): fetch
/.well-known/agent-card.json, verify its signature if published, cache it with itsversionandETag. - Authorize: obtain a token per the declared
securitySchemes. - Delegate:
SendMessagewith a clear task message; keeptaskId/contextId. - Collaborate: stream or poll; answer
input-requiredandauth-requiredprompts on the same task. - Close: read artifacts on
completed; callCancelTaskon business aborts; record everything in your audit log.
Frameworks make step 1-6 shorter - Google ADK, LangGraph, CrewAI, and the OpenAI Agents SDK all expose A2A server/client integrations - but none of them remove the governance steps. The protocol is thin on purpose; the operating discipline is yours.
Conclusion & Next Steps
Cross-organization agent collaboration fails on the seams - discovery, trust, and accountability - not on model quality. A2A addresses each seam with a web-standard artifact: the Agent Card for discovery, JSON-RPC tasks for delegation, declared security schemes for trust, and versioned contracts for lifecycle management. The result is a multi-vendor stack where your partner’s agent stays opaque, your agent stays opaque, and the work still gets done.
Homework for your next integration review:
- Publish a signed Agent Card for one of your internal agents and diff it in CI like an API contract.
- Move one partner integration from ad-hoc REST calls to
SendMessage/GetTaskand measure the reduction in integration code. - Add
auth-requiredhandling to your A2A client and verify a full mid-task credential round-trip.
Sources: A2A Protocol repository (google/A2A), A2A Protocol Specification, A2A Enterprise Features