AOS/agency-agents/skills/handoff/SKILL.md

name, version, applies_to, risk

name	version	applies_to	risk
handoff	1.0.0	orchestrator software-lead support-lead ads-lead social-lead marketing-lead accounting-lead license-lead	low

Structured Delegation (AgentHandoff)

When to use

Any time one agent needs another agent to do work. There is no free-form chat between agents — every delegation is a structured AgentHandoff so the task tree stays debuggable and the costs stay aggregatable.

Steps

1. Read the goal and the originating task_id (AOS-NNNN) from the parent task.
2. Identify the target department lead by routing rule (software→software-lead, support→support-lead, ads→ads-lead, social→social-lead, marketing→ marketing-lead, licenses→license-lead, accounting→accounting-lead).
3. Load the target agent's spec from agents/<dept>/<name>.md and read its tools, forbidden, budget, and autonomy frontmatter — the handoff must respect every one of those, or you have the wrong agent.
4. Compose the AgentHandoff per schemas/handoff.json:
   • task_id (the AOS id), from, to, goal (one business sentence),
   • inputs[] (AOS record ids / asset refs the worker can read),
   • constraints (budget_eur, max_tokens, deadline, autonomy override),
   • definition_of_done[] (≥1 concrete verifiable outcome),
   • output_format (one of: aos_deliverable, report, draft, review_verdict, data),
   • needs_approval_for[] (every high-risk action this task may reach — spend, publish, send, revoke, delete, deploy, migration, etc.),
   • context_refs[] (client_id, project_id, contract_id as needed).
5. Validate the payload against schemas/handoff.json before dispatch. If validation fails, fix and re-validate — never dispatch an invalid handoff.
6. Dispatch via the AOS handoff endpoint; log the dispatch as a note on the parent task with to, goal, and the deadline.
7. Await the receiving agent's AgentDeliverable (schemas/deliverable.json). While waiting, do nothing else on this task branch.
8. On receipt, validate the deliverable shape. Then:
   • done → aggregate cost into the parent task, mark the branch complete.
   • needs_review → route to code-reviewer / reviewer / lead as relevant.
   • needs_approval → surface the ApprovalRequest to the human owner; do not approve it yourself.
   • blocked → read open_questions[]; answer from AOS context or escalate to the human owner. Never invent answers.
9. Aggregate cost.tokens and cost.eur across all handoffs on the task. If cumulative spend approaches the task budget cap, pause and request a budget increase (human gate).

Inputs

• A parent task in AOS with a clear goal and task_id.
• The target agent's spec file (to read constraints).
• Sufficient AOS context refs (client/project/contract) for the worker.

Outputs

• A validated AgentHandoff written to AOS and linked to the parent task.
• A receipt of the resulting AgentDeliverable, with cost aggregated.
• A note on the parent task summarizing the delegation and its outcome.

Guard rails / compliance

• Never bypass an approval gate surfaced by the worker — escalate, never approve your own delegation's high-risk action.
• Never dispatch without a definition_of_done; an empty array is invalid.
• Never invent client decisions to unblock a worker — escalate instead.
• Every dispatch and receipt is logged to AOS; no private state between runs.
• Respect the worker's forbidden tools — if the task needs one, the task belongs to a different agent.

References

• schemas/handoff.json — AgentHandoff shape
• schemas/deliverable.json — AgentDeliverable shape (return envelope)
• schemas/approval.json — ApprovalRequest shape (when worker pauses)
• policies/autonomy.md — L0/L1/L2 and the always-human-gated list
• agents/cross-cutting/orchestrator.md — routing rules by department