# What is Delegation?

Also called agent delegation, task assignment.

Delegation is when one agent assigns a subtask to another agent and remains responsible for the outcome. The delegating agent frames the request, supplies the context the other will need, and receives a result to check and integrate. It differs from a handoff, where responsibility for the interaction transfers away and does not return.

Delegation is implemented in several ways: an agent exposed to another as a callable tool, a supervisor that names which specialist should run next, or an explicit task queue that workers pick from. The common structure is that the delegator keeps the overall goal and only the subtask travels, so the specialist works in a small, clean context.

The quality of a delegation is set by the brief. The receiving agent sees only what it is sent, so an underspecified request produces work against assumptions the delegator never intended. Effective briefs state the objective, the constraints, the format expected back, and what has already been tried. This is the single most common source of failure in multi-agent systems.

Because responsibility stays with the delegator, the returned result should be checked rather than accepted. A specialist can return something confident, well formatted, and wrong. Systems that integrate subtask results without verification propagate errors upward, and the failure then appears in the final answer with no obvious link to the step that caused it.

Delegation only pays off when the subtask is genuinely separable and the brief can be written compactly. Work requiring constant back and forth is usually cheaper to keep in one agent. Related ideas are the supervisor pattern, which formalizes who delegates, handoff, which transfers rather than lends responsibility, and task decomposition, which produces the units to delegate.

## Key points

- The delegator keeps responsibility and checks what comes back.
- Only the subtask and its brief travel, not the whole context.
- Underspecified briefs are the top cause of multi-agent failure.
- Tightly coupled work is cheaper to keep in one agent.

## In practice

A research agent needs current pricing for four competitors. Rather than browsing itself and filling its context with page markup, it delegates each site to a fetching agent with a precise brief: return the plan names and listed figures as a short table, nothing else. Four compact tables come back. The research agent verifies each looks plausible, then writes its comparison.

## Related terms

- [Supervisor Agent](/en/glossary/supervisor-agent)
- [Handoff](/en/glossary/handoff)
- [Multi-Agent System](/en/glossary/multi-agent-system)
- [Task Decomposition](/en/glossary/task-decomposition)
- [Agent Orchestration](/en/glossary/agent-orchestration)

[Back to the AI Glossary](/en/glossary)