Skip to main content

Module 6 — Delegation and supervision

Delegation is the feature that makes a CrewAI crew feel like a team and, without care, the feature that makes it feel like a helpdesk queue where every agent asks every other for advice. This module explains what the allow_delegation flag actually enables, why it is off by default in this course, and how the Manager agent supervises the arbitration between the Writer and the Reviewer without triggering the loops that plague first-time crews.

What allow_delegation=True actually does​

When an agent is created with allow_delegation=True, CrewAI injects two extra tools into its toolbox on every task:

  • Delegate work to coworker — hand a sub-task to another agent, with a description of the sub-task and a context string, and receive the co-worker's result as the tool's return value.
  • Ask question to coworker — the lightweight variant: pose a single question and receive an answer, without transferring the whole sub-task.

Both tools appear as ordinary tool calls in the ReAct loop of the agent (course 30). The delegator formulates a natural-language brief, the delegatee runs a full sub-agent turn with its own model and tools, and the result comes back as text. It is powerful and it is expensive: each delegation is a full extra round trip to a model.

Why it is False by default in this course​

In module 2 we set allow_delegation=False on the Analyst, the Writer and the Reviewer. That was not a stylistic preference. Consider the alternative: the Analyst reads the brief, notices an ambiguous constraint, and delegates a "clarify this constraint" sub-task to the Writer. The Writer, unequipped for research, delegates the same question back to the Analyst. Neither has a tool to actually resolve the ambiguity, so the sub-task ping-pongs until CrewAI hits its iteration cap.

This is not a hypothetical failure mode. It is the single most common way a first crew burns through its API budget in an hour: three agents with allow_delegation=True and no clear responsibilities produce a chat room, not a pipeline. The rule is simple — delegation is a supervisor privilege, not a peer privilege. Only the Manager should have it in a sequential crew.

The Manager's job, done well​

The Manager has allow_delegation=True and one task: arbitrate. Its input is the Reviewer's verdict (module 3), its output is a reconciled draft. When the verdict is approve, its job is trivial — pass through. When the verdict is reject, it must decide whether the Reviewer's issues are worth another Writer pass or whether the crew ships as is with a note.

arbitrate = Task(
    description=(
        "Read the reviewer verdict and the current draft. "
        "If verdict == 'approve', pass the draft through unchanged. "
        "If verdict == 'reject' and issues are stylistic only, delegate a "
        "focused rewrite of the affected paragraphs to the Writer. "
        "If verdict == 'reject' and issues are factual, block the run "
        "and return a summary of the blocking issues — do not delegate."
    ),
    expected_output=(
        "A JSON object {action: 'passthrough'|'rewrite'|'block', draft?: string, "
        "block_reason?: string}."
    ),
    agent=manager,
    context=[draft_sections, review_draft],
)

Three properties of this task make delegation safe. First, delegation is conditional — only stylistic rejections go back to the Writer, factual ones block. Second, the delegated sub-task is focused ("rewrite the affected paragraphs") rather than open ("fix everything"). Third, the expected output enumerates the three legal outcomes, so the Manager cannot invent a fourth like "keep debating".

Capping the conversation: max_iter and max_rpm​

Even with a disciplined Manager, defense in depth matters. Two flags cap the worst case.

  • max_iter on an agent bounds the number of ReAct loop iterations per task. The default is 25. Bring it down to 10 for a task that should complete in a few turns; a loop of 20+ is almost always a broken tool or a bad delegation, not real work.
  • max_rpm on the crew (or per agent) bounds the model calls per minute. Set it to your provider's tier limit to avoid throttling errors that CrewAI will interpret as tool failures and retry.
manager = Agent(
    role="Editorial Manager",
    ...,
    allow_delegation=True,
    max_iter=8,
)

crew = Crew(agents=[...], tasks=[...], process=Process.sequential, max_rpm=30)

Two numbers, one line, saves you a $200 incident.

Asking a question versus delegating a task​

When the Manager needs a small clarification — "is section 3 covered by the security constraint on line 42?" — the right tool is Ask question to coworker, not Delegate work to coworker. The difference is proportionality: asking is one round trip with one message, delegating is a full sub-agent turn with its own iteration budget. Using delegation for a question is like scheduling a meeting to ask what time it is.

In practice, the model chooses the right tool if the delegation description is short and the question description is really a question. If your traces show the Manager delegating whole rewrites when a one-line answer would do, tighten the Manager's backstory ("prefer a single clarifying question over a delegation whenever possible") and cap max_iter.

Reading a delegation trace​

A healthy delegation trace has three visible parts, and any missing part is a bug.

  • Motivation: the Manager's thought explaining why it is delegating ("the review flags a style issue on section 5; I will ask the Writer to rewrite that section only").
  • Focused brief: the argument to the delegation tool naming the exact scope ("rewrite section 5 to remove marketing verbs; keep the feature list identical").
  • Bounded acceptance: the Manager's follow-up thought comparing the returned rewrite to the Reviewer's issues and moving on — not asking for another rewrite unless a new issue appears.

A trace where step three loops back to step two more than once per issue is a loop; either the delegatee is confused or the brief is not focused enough. Fix the brief first.

Two agents with allow_delegation=True is one too many

The rule for this course: exactly one agent with delegation enabled — the Manager — and everyone else answers what they are asked. This single rule prevents ninety percent of the "my crew ran for twenty minutes and produced nothing" stories.

Summary​

  • allow_delegation=True injects two tools into the agent — delegate a sub-task and ask a question — each of which is a full extra model round trip.
  • Only the Manager delegates in a sequential crew; peer-to-peer delegation creates loops and burns budget without adding cross-checks.
  • The Manager's arbitration task lists explicit legal outcomes (passthrough | rewrite | block) and delegation is conditional and focused — factual rejections block, stylistic ones trigger a targeted rewrite.
  • Cap the worst case with max_iter per agent (default 25, prefer 8 to 10) and max_rpm per crew; two numbers avoid a runaway bill.

Next module: the memories that make an agent remember its previous turn — short-term, long-term and entity — and the trade-off between recall and context bloat.