Recursive agents that can't run away.
Agents that call agents — recursively, sometimes calling themselves — are how hard problems get decomposed. They're also how systems lose the plot: each level reuses the same broad credential, the call tree vanishes into interleaved logs, and a deep chain spends and escalates until something breaks. a2a cloud makes recursion attenuate authority at every level, hash-chains the entire call tree, and lets you replay any subtree on its own. Decomposition without the runaway.
authority attenuates with depth · hash-chained tree · bounded budget
Deep recursion accumulates authority it should be shedding.
The intuition of recursion is that each level does less — a smaller slice of the problem, with less at stake. Most agent stacks invert that for authority: every recursive call carries the full credential of the root, so a leaf ten levels deep can do everything the top-level agent can. Add interleaved logs and unbounded cost and a recursive run becomes something you can neither trace nor safely let loose. The deeper it goes, the less you can account for it.
Tie depth to attenuation and sign the whole tree.
a2a makes each recursive level strictly less powerful than its parent and records every node, so recursion is bounded by authority and budget and provable end to end.
Authority shrinks as you recurse
Each recursive call issues a grant that is a strict subset of the level above it. The deeper the recursion, the narrower the authority — depth attenuates access instead of accumulating it.
The call tree is hash-chained
Every level's runs are Ed25519-signed and linked, so the full recursion tree is a tamper-evident record. You can walk from the root call to any leaf and prove the path.
Depth and budget are bounded
Grants carry TTLs and scope, and each agent has per-run cost attribution, so runaway recursion hits authority and budget limits instead of quietly spending or escalating.
Replay any subtree
Deterministic replay works at any node, so you can re-run a single branch of the recursion to reproduce a result or isolate where a deep chain went wrong.
Unbounded recursion vs. attenuated recursion.
Frequently asked.
What are recursive AI agents?
Recursive AI agents are agents that call agents — including instances of themselves — to break a problem into sub-problems, solve each, and combine the results. The pattern is powerful but dangerous without limits: depth can accumulate authority and cost, and the call tree can become impossible to trace. On a2a cloud each recursive call runs under a grant that's a strict subset of its parent's, and every level is signed, so recursion stays bounded and auditable.
How do you stop recursion from escalating access or cost?
Authority only attenuates downward. A parent call can grant a child a subset of what it holds and no more, and grants carry short TTLs and explicit scope, so deeper levels have strictly less power than shallower ones. Combined with per-run cost attribution, a runaway branch hits authority and budget limits rather than silently spending or acquiring access it shouldn't have.
Can I trace and reproduce a deep recursive run?
Yes. Every level of the recursion emits an Ed25519-signed, hash-chained receipt, so the entire call tree is a tamper-evident record you can walk from the root down to any leaf. Deterministic replay works at any node, which means you can re-execute a single subtree to reproduce a result or pinpoint exactly where a deep chain diverged.
Related guides.
All guides live in the guides index.
Recurse as deep as you like. Keep the tree.
a2a cloud deploys any agent — LangGraph, OpenAI Agents SDK, CrewAI, or custom — with a managed Postgres database, an MCP server, an API, and an Ed25519-signed receipt for every run at every level. Authority attenuates with depth, cost is attributed per run, and any subtree replays on demand. Recursion with a paper trail.