a teammate
one-process team
A role prompt inside one shared process.
a2a team
A deployed agent with its own DB boundary and signed evidence on those runs.
teams with a ledger
Autonomous agent teams, accountable by member.
A team of agents divides labor—a researcher, builder, and reviewer. a2a cloud can make each teammate a separate deployable with isolated Postgres. Supported handoffs carry scoped grants, while worker runs produce member-attributable signed evidence and formal A2A messages remain protocol state.
own DB per member · scoped handoffs · per-teammate evidence
0
isolated database per teammate
0
shared credential across the team
0
signed execution entry points per member
the problem
A 'team' that shares one process shares one blast radius.
The promise of an agent team is specialization — each member an expert, working in parallel. The common implementation undercuts it: role prompts in a single process, one credential, one database, one bill. Nothing about that is a team. When output is wrong you can't tell which member caused it; when access is breached every member had it; when you want to change one specialist you redeploy all of them. The org chart says team; the runtime says monolith.
Members are role prompts in one process, not independent agents.
One shared credential and database means one shared blast radius.
Actions and cost can't be attributed to a specific teammate.
Changing one member forces a redeploy of the whole team.
the a2a way
Make every teammate a real deployable with execution evidence.
a2a gives each member separate deployment and database boundaries, scoped delegation where used, and signed evidence on those runs so the team remains inspectable by member.
Each teammate is its own agentCollaboration through scoped handoffsPer-member accountability and costAdd or retire members independently
Each teammate is its own agent
Every member of the team is a separately deployed agent with its own identity, isolated Postgres, and skills. Division of labor is real — a teammate's data and failures are its own, not the team's.
Collaboration through scoped handoffs
When teammates pass work, the exchange can carry a scoped grant. A worker skill executed through the API, MCP, or /invoke entry point receives a receipt with caller, skill, input evidence, verified grant IDs, outcome, and timing; the handoff timeline is separate protocol history.
Per-member accountability and cost
Signed execution receipts are attributable per agent on the API, MCP, and /invoke entry points. Authenticated Agent API paid calls also create separate receipt-linked economics; direct `/invoke` and standard MCP gateway receipts record zero platform economics.
Add or retire members independently
Because members are independent deployables, you can add or replace a specialist independently. Scoped grants can be revoked or re-scoped without rotating a shared credential.
side-by-side
Role-prompt monolith vs. real agent team.
collaboration
one-process team
Messages passed in memory with no record of authority.
a2a team
Scoped grants between members, with handoffs kept in separate ordered protocol history.
accountability
one-process team
The team acted — which member is anyone's guess.
a2a team
Per-member signed run evidence plus separate cost attribution.
changing the roster
one-process team
Edit the shared prompt and redeploy the whole team.
a2a team
Add, swap, or revoke one member without touching the rest.
dimension
one-process team
a2a team
a teammate
A role prompt inside one shared process.
A deployed agent with its own DB boundary and signed evidence on those runs.
collaboration
Messages passed in memory with no record of authority.
Scoped grants between members, with handoffs kept in separate ordered protocol history.
accountability
The team acted — which member is anyone's guess.
Per-member signed run evidence plus separate cost attribution.
changing the roster
Edit the shared prompt and redeploy the whole team.
Add, swap, or revoke one member without touching the rest.
questions
Frequently asked.
What is an autonomous agent team?
An autonomous agent team is a set of specialists collaborating on one objective. On a2a cloud, teammates can be separate deployables with their own database boundaries. Platform-managed handoffs can carry scoped grants, and executions through Agent API, public `/invoke`, or standard MCP `tools/call` produce signed evidence attributable to the member.
How do teammates collaborate without sharing one credential?
Platform-managed handoffs can carry a grant bound to an audience, scope, and TTL rather than sharing a common key. Worker runs produce their own signed evidence; formal A2A messages and any separately configured ordered session remain distinct protocol and history records.
Can I measure and audit each member of the team separately?
Each teammate can be its own deployed agent, so execution evidence resolves to that member. Current receipts sign caller, skill, input evidence, the grants that authorized it, result preview, and timing. Only authenticated Agent API paid calls create a separate ledger row with compute and price fields; direct gateway receipts record zero economics.
keep reading
Related guides.
All guides live in the guides index.
don't trust the agent
Build a team, not a monolith with hats.
a2a cloud deploys any agent so teammates get managed Postgres, MCP and API surfaces, and scoped grants. Agent API, public `/invoke`, and standard MCP `tools/call` executions receive receipts. Only authenticated Agent API paid calls have linked economics; gateway receipts record zero.