a handoff
plain handoffs
An HTTP call with a shared key and no record of intent.
a2a orchestration
A scoped exchange plus separate signed evidence when the worker uses the API, MCP, or /invoke path.
orchestration you can prove
Multi-agent orchestration, governed at each execution.
Orchestration frameworks are good at the how — routing tasks, passing results, fanning out and joining. What they leave open is the who: which agent called which and under whose authority. a2a cloud carries scoped grants through supported handoffs, routes by capability discovery, signs worker runs, and preserves ordered history for inspection. Formal A2A messages remain protocol state rather than signed skill executions.
scoped handoffs · discovery routing · signed worker executions
0
the API, MCP, and /invoke entry points
0
shared broad credential
separate ordered workflow history
the problem
You can see the calls. You can't prove the authority.
A multi-agent system is a distributed system, and distributed systems fail at their seams — the handoffs. Most stacks make those handoffs plain HTTP calls with a shared key: no record of intent, no scoping, no way to reconstruct the exact path a task took. When an orchestrated workflow does something wrong, you're left correlating logs across services, guessing which hop misbehaved, and unable to show under whose authority each step ran. Observability shows the traffic; it doesn't prove the chain.
Handoffs are anonymous HTTP calls sharing one broad credential.
Routing is hard-coded, so the graph rots as agents come and go.
Authority stays wide across every hop instead of narrowing.
Reconstructing a run means stitching logs from many services.
the a2a way
Make the orchestration graph governed and inspectable.
a2a adds identity, scoped grants, signed evidence on worker runs, and separate ordered history to the seams between agents—so a workflow can be inspected without calling every formal handoff a signed skill run.
Scoped handoffs, not blind callsDiscovery-driven routingGrants narrow across hopsInspect the whole workflow
Scoped handoffs, not blind calls
When one agent hands off to another, the caller's scoped grant can travel with the request and the exchange remains protocol history. Worker runs receive separate signed receipts with the grants that authorized it.
Discovery-driven routing
Orchestrators route by capability with `ctx.discover.find_agents(skill=...)` instead of hard-wired addresses. Add or replace a worker and routing follows the capability, not a brittle config.
Grants narrow across hops
Delegation can narrow authority at each handoff so a downstream grant is no broader than its parent. Separately configured credentials and arbitrary direct calls remain outside that guarantee.
Inspect the whole workflow
Covered skill executions receive signed receipts, while formal A2A handoffs remain protocol state in separate ordered event history. Deterministic re-execution requires replay doubles and seeded randomness; it is not automatic.
side-by-side
Anonymous calls vs. governed orchestration.
routing
plain handoffs
Hard-coded endpoints that rot as the fleet changes.
a2a orchestration
Capability discovery — route by what an agent can do.
authority
plain handoffs
Every hop holds the same broad credential.
a2a orchestration
Authority narrows step by step down the chain.
debugging
plain handoffs
Correlate logs across services and hope timestamps line up.
a2a orchestration
Scrub the signed ordered event history across the graph.
dimension
plain handoffs
a2a orchestration
a handoff
An HTTP call with a shared key and no record of intent.
A scoped exchange plus separate signed evidence when the worker uses the API, MCP, or /invoke path.
routing
Hard-coded endpoints that rot as the fleet changes.
Capability discovery — route by what an agent can do.
authority
Every hop holds the same broad credential.
Authority narrows step by step down the chain.
debugging
Correlate logs across services and hope timestamps line up.
Scrub the signed ordered event history across the graph.
questions
Frequently asked.
What is multi-agent orchestration?
Multi-agent orchestration coordinates specialized agents, passes intermediate results, and combines outputs. The hard part is knowing who called whom under what authority. a2a supports scoped grants on managed handoffs and signs worker executions on Agent API, public `/invoke`, and standard MCP `tools/call`; formal A2A exchanges remain protocol history.
How is this different from an orchestration framework like LangGraph or AutoGen?
Frameworks define how agents coordinate; a2a governs it. Each agent gets its own identity and managed Postgres, and handoffs can carry scoped grants that narrow at each hop. Skill executions through the Agent API, public `/invoke`, or standard MCP `tools/call` receive receipts; formal A2A message/task steps do not automatically do so.
Can I audit a multi-hop agent workflow end to end?
Covered skill-execution receipts record caller identity/classification, skill, input evidence, verified grant IDs, outcome, and timing. A separately signed replay session can preserve ordered handoff history. Formal A2A routes remain protocol state, and deterministic re-execution requires replay doubles plus seeded randomness.
keep reading
Related guides.
All guides live in the guides index.
don't trust the agent
Orchestrate agents. Prove the graph.
a2a cloud deploys any agent with managed Postgres, MCP and API surfaces, a frontend, scoped grants, and signed ordered history. Skill executions through Agent API, public `/invoke`, and standard MCP `tools/call` receive receipts; formal A2A handoffs remain separate protocol state.