How Do Agents Delegate Work to Each Other? A2A Delegation

So far, we’ve covered what an agent is, where it fits in the org chart, and what its policy.md tells us about boundaries. But in the real world, agents do work—and sometimes that work needs to be handed off to another agent.

A human manager delegates: “Ali, prepare this report.” If Ali has limitations (say, no authority for overtime), he asks the manager. The manager says “Yes, go ahead,” and Ali gets it done.

What happens when Agent A hands work to Agent B? And who approves it?

From Human Manager to Agent Coordinator

When A tries to delegate to B, the system checks B’s policy.md. If it says “Agent B only queries databases—no external API calls,” then A cannot delegate that kind of work to B. A would need to ask a higher authority (both A and B’s owner or a common supervisor). They might say “Yes, expand B’s scope this time” or “No, try Agent C instead.”

The fundamental principle: A2A delegation always comes with accountability tracking. Even after A hands off work to B, A remains responsible for the outcome. B does the work, but A reports the result.

The Approval Chain

What gets checked before delegating work?

1. B’s authority: Does B’s policy.md permit this task?
2. B’s capacity: What is B currently doing? Can B take on more work?
3. Result verification: Who will oversee B’s output? This is specified in B’s policy.md. For example: “All of Agent B’s deliverables must be verified by Human Data Controller C.”
4. Risk level: If the task is high-risk (transferring money, changing client contracts), who provides additional approval? This is also in the config.

Real example: A recruitment scheduler agent (recruitment_scheduler) needs to coordinate with an HR assistant agent (HR_assistant) to open three new engineer positions.

recruitment_scheduler: "HR_assistant, we need to open 3 engineer positions."
HR_assistant checks policy.md: "Can open job postings. 
But 5+ positions need human HR Manager sign-off."

HR_assistant: "3 positions is within my scope. Opening them now.
Notifying you when done."

recruitment_scheduler: "Thanks. Logging this. Reporting to humans that 
3 positions are live."

The approval flow:

• recruitment_scheduler → HR_assistant: Delegation request
• HR_assistant checks policy: Yes, 3 positions allowed
• HR_assistant checks owner: No extra human sign-off needed (policy pre-approved this)
• HR_assistant → recruitment_scheduler: Result notification
• recruitment_scheduler logs it for audit and human review

Result Tracking and Audit Trail

Agent A delegates to B. B completes the work. Where does the result get recorded?

This is critical: Every agent must maintain an audit log. Who did what, when, and with what result must be recorded. Example:

• Timestamp: 2026-09-02 10:00 UTC
• Requester: recruitment_scheduler
• Recipient: HR_assistant
• Task type: Open job postings (3 count)
• Policy check: Approved (below 5-position threshold)
• Result: Postings created, IDs: JOB-001, JOB-002, JOB-003
• Logged by: HR_assistant
• Human observer: [HR Manager reviews logs periodically via another tool]

Without this audit trail, three problems return:

1. Shadow AI resurfaces: Nobody knows which agent did what or why.
2. Errors can’t be traced: B gave a bad result, but whose fault is it?
3. Authority gets bypassed: An agent secretly delegates to another agent and gets results outside of oversight.

Delegation Library (Framework)

A mature system has these components:

1. Delegation config: Which agents can delegate to whom
2. Policy skill matrix: What each agent can and cannot do in each skill (e.g., HR_assistant can query salaries but cannot change them)
3. Request template: What info must A include when asking B (urgency, estimated time, required resources)
4. Acceptance logic: If B cannot accept (capacity, authority), to whom does the system escalate? (Human manager, Agent C, or deny)
5. Result notification: B completes work, A receives result, logs it, reports to human observer

Human organizations already do this. “Ali, give this work to Zeynep, but first check X.” The same must happen with agents—written, automated, and verifiable.

Summary

When Agent A delegates to Agent B:

1. Check B’s policy.md (is this task within B’s authority?)
2. Check B’s capacity (is B available?)
3. Look up delegation config (can A really delegate to B?)
4. Build request using template (what info does B need?)
5. Await B’s response (accept, reject, or escalate?)
6. Receive result, A logs it, human observer reviews logs

All of this must be documented. Config, policy, and audit trail.

Tomorrow: What happens when humans and agents work side by side?