Delegation and handoffs

Delegation is a context boundary

The main reason to delegate is not specialisation, it is context. A subtask that needs twenty documents and one answer can do that work in its own window and return a paragraph, leaving the parent’s context clean.

That is also the cost: the parent cannot see the work, only the result. If the result is wrong, the parent has no way to tell whether the subtask failed or the question was wrong.

Picture a parent agent answering “what is our refund policy for gift cards”. It delegates to a research agent with the policy index, which reads twenty passages and returns three findings with sources. The parent never sees the twenty passages, which is the benefit. It also cannot see that two of them contradicted each other, which is the risk, and why the result needs a confidence and a stopped reason rather than a paragraph.

Give the sub-agent a contract

A handoff should state the goal, the inputs, the allowed tools and the shape of the result. That is the same four-part prompt from the first course, applied to an agent instead of a model call.

The result shape matters most. “Return a summary” gives the parent a paragraph it has to interpret. “Return findings, sources and confidence” gives it a value it can branch on.

The contract should also say what the sub-agent must not do. “Do not write to the index”, “do not contact the customer”, “do not spend more than five steps” are boundaries the parent can enforce even if the child ignores them. The child’s prompt states them; the parent’s code checks them. A contract that only lists the goal is a wish, not a delegation.

A handoff with a contract

result = research_agent.run(
    goal="Find the refund window",
    inputs={"policy_id": "billing#refunds"},
    tools=["search", "read"],
    budget={"steps": 5},
)
# {"findings": [...], "sources": [...], "confidence": 0.8, "stopped": "answered"}

The handoff is a contract, not a conversation

The parent should be able to branch on the result without reading it. A handoff that returns findings, sources, confidence and a stopped reason gives the parent four facts: what was found, where it came from, how much to trust it, and whether the sub-agent finished. A handoff that returns a paragraph gives the parent text and hope.

A common mistake is letting the sub-agent decide the shape of its answer. It writes a helpful summary, the parent parses it with a regular expression, and the first reworded summary breaks the parent. Fix the shape in the contract, validate it at the boundary, and let the sub-agent spend its freedom on the research rather than on formatting.

The sub-budget is not optional

A delegated agent that can spend without limit is a way to turn one request into an unbounded bill. Give it its own step and token budget, smaller than the parent’s remaining budget, and treat exhaustion as a normal result.

The parent should also keep a global budget. A sub-agent that returns “out of budget” is a signal to stop delegating, not to try again with a bigger allowance.

When one agent is enough

Splitting into agents adds a contract, a budget, a failure path and a place for the result to be misunderstood. It pays when the subtask is genuinely separable: different tools, different context, different owner.

If the subtask shares the parent’s tools and context, it is a function. Call it as one and skip the ceremony.

A useful test is to write the handoff contract. If you cannot name a result shape that the parent needs and the child can produce, the subtask is not separable yet. If the contract is just the parent’s question restated, you are paying for a second context to do the same job. The test is cheap and it happens before you build the second agent, which is the right time to discover that you do not need one.