A2A audit trail: what to capture

Agent-to-agent calls cross a trust boundary, and an A2A audit trail has to treat that crossing as the event worth recording. When one agent invokes another, you are not watching a function run inside one process; you are watching one autonomous actor ask another to do something on its behalf. If you only record what each agent did internally, you miss the handoff, which is exactly where accountability lives.

The checklist

A complete A2A audit trail captures, for every cross-agent call:

• The calling agent's identity, tied back to the human or workflow that started the chain
• The called agent's identity, as its own actor, not an extension of the caller
• The action requested across the boundary, with its arguments
• What the called agent then reached, and the result it returned
• Whether the call required and received an approval
• Sensitive values masked in the recorded payload

Why the handoff is the hard part

Internal agent logs stop at the process edge. The A2A call leaves one agent and enters another, and if both agents log only their own side under shared or implicit identities, the chain breaks at the boundary. You end up able to see two halves that you cannot stitch into one accountable sequence.

Capture it where the call crosses

The architectural requirement follows directly: record the call at the boundary it crosses, with both agents named by their own scoped identities, checked against policy, in a record neither agent can edit. That is one control surface, and hoop.dev is built to it. Cross-agent calls travel through hoop.dev as an identity-aware proxy, each is written as a command-level audit with both identities attached, and sensitive payloads are masked inline. In practice you route agent-to-agent access through hoop.dev and the handoffs become first-class records. The getting-started guide covers the first connection, and hoop.dev/learn explains cross-agent attribution.

How to use the checklist

The checklist is only useful if it maps to questions an investigation actually asks. Walk through a single handoff to see how. Agent A, a planner, asks agent B, a data worker, to assemble a report. Six weeks later, customer data shows up somewhere it should not. With the A2A audit trail in place, you start at the handoff record: agent A's identity, agent B's identity, the request that crossed, what B then reached, and the result. Each captured field answers a specific question. The calling identity tells you who initiated it. The called identity tells you which agent actually touched data. The recorded action tells you what was asked across the boundary. The downstream reach tells you what B did with the request.

What it rules out

A complete handoff record is as valuable for what it clears as for what it catches. If agent B's identity never appears reaching the customer data in question, B is ruled out, and you move up the chain to whatever called A. Without cross-agent attribution, you cannot do this: every agent looks equally possible because none of the handoffs were recorded as their own events. The A2A audit trail turns a vague "one of our agents did something" into a precise path you can follow or eliminate, link by link, which is the entire reason to record the crossing rather than just each agent's private view of its own work.

Try it on one handoff

hoop.dev is open source. From the GitHub repository, put one agent-to-agent call behind it and confirm the record names both agents.

FAQ

Why record the handoff separately?

Because accountability lives at the boundary. Each agent's internal log cannot, on its own, prove who asked whom to do what.

What if agents are on different services?

Route their cross-service access through the same boundary so the calls land in one consistent record regardless of where each agent runs.

Do both agents have to be built by the same team?

No. They only need their cross-agent access routed through the same boundary, even if different teams built them. That shared boundary is what lets one handoff record name both the calling and the called identity, which is the entire point of an A2A audit trail.