Agent Call Chain: How A2A Work Delegation Actually Works

Yesterday, we learned that org charts must include agents—each with an owner (responsible_id) and a policy. Today: once you have that structure, how does one agent hand work to another? Is a simple “You handle this customer query” enough?

No. Because as agents work, they constantly delegate to each other, and every handoff carries risk.

Real Scenario: Content Moderation Chain

An e-commerce company has three agents:

1. content_reviewer: Reads customer reviews, flags those needing action (sexual content, threats, spam)
2. policy_classifier: Categorizes flagged reviews (category: “spam”, “offensive”, “suspicious”, “clear”)
3. removal_executor: Performs the actual deletion, notifies admin

One morning, a thousand reviews arrive. content_reviewer doesn’t have time for all of them. What happens?

content_reviewer: "policy_classifier, I have 100 reviews here.
                   Can you categorize them?"

But what needs oversight before this handoff happens?

1. Authority Check: policy.md

Read policy_classifier’s policy.md:

classifier_policy.md:
- Skill: Comment classification
- Boundaries:
  - Max 500 reviews/day
  - Only English/Turkish
  - Cannot make "removal_decision" (only flag)
- Result verification: Requires content_reviewer manual review

The agent receives 100 reviews. Within the 500/day limit. Authority is there. BUT: the policy says results must be verified by content_reviewer—creating a feedback loop. Without this, policy_classifier works in silence (shadow AI).

2. Capacity Check: Helper System

The delegating agent (content_reviewer) must know the recipient’s (policy_classifier) current state:

capacity_check():
  policy_classifier.current_queue_length = 450 reviews
  policy_classifier.daily_limit = 500
  available_capacity = 500 - 450 = 50

content_reviewer: "I have 100 but only 50 slots free.
                   Ask another classifier or wait."

When capacity is exceeded, options:

• Escalate to policy_classifier’s owner: “Can we raise the limit?”
• Try a second classifier (policy_classifier_v2)
• Split the batch: process 50 now, queue 50 later

3. Risk Level: Escalation Gate

What risk does “delete a review” carry? High. A customer could sue.

risk_assessment():
  for review in reviews:
    if contains("lawsuit", "legal action"):
      risk_level = HIGH
      required_approvers = [content_officer, legal_reviewer]
    elif contains("personal_data"):
      risk_level = MEDIUM
      required_approvers = [content_officer]
    else:
      risk_level = LOW
      required_approvers = []

High-risk reviews? policy_classifier cannot handle them. The batch is redirected to legal_reviewer or escalated to a human:

policy_classifier: "Of 100 reviews, 3 contain legal risk language.
                    Redirecting those 3 to legal_reviewer.
                    Processing remaining 97."

4. Veto Right: Recipient Can Object

Critical rule: An agent is not forced to accept work.

policy_classifier receives the request and responds:

policy_classifier: "20 of these 100 reviews contain video—
                    they need OCR extraction. That's outside 
                    my scope. Redirect to video_analyzer please."

A veto right? The space where an agent can say “I can’t do this.” But the refusal must be logged:

Log Entry:
- Request time: 2026-09-09 14:30
- Requester: content_reviewer
- Recipient: policy_classifier
- Task: Classify 100 reviews
- Status: PARTIAL_ACCEPTED (20 -> video_analyzer, 80 -> proceeded)
- Reason: Video content falls outside scope
- Next action: content_reviewer redirects video batch to video_analyzer

Without this log, content_reviewer never notices the 20 missing reviews and reports “100 processed.”

5. Result Notification: Closing the Loop

policy_classifier finishes its work. What happens?

policy_classifier -> content_reviewer:
  "100 review classification complete.
   Results: 45 spam, 30 offensive, 15 suspicious, 10 clear.
   Report attached: results.json
   Processed by: policy_classifier
   Time: 2026-09-09 14:45
   Next: content_reviewer approves results."

content_reviewer -> removal_executor:
  "Based on policy_classifier's report, delete the 45 spam.
   Flag 30 offensive for human decision."

The chain continues. Each agent receives a result, logs it, and passes work forward.

A2A Delegation Template

Every agent-to-agent handoff should complete this form:

Summary: Responsibility Chain in Agent Economy

Delegating work to an agent isn’t just about positive output. A healthy system:

1. Authority check: Does policy.md allow it?
2. Capacity check: Can the agent handle it right now?
3. Risk assessment: Who needs extra sign-off?
4. Veto mechanism: Can the agent object?
5. Loop closure: Every step is logged, results are recorded

Without these, an “agent economy” becomes “agent chaos.”