Delegation is how a task gets from the person or agent who received it to the person or agent who should actually do it. In Company Agents, delegation is a first-class operation with its own audit trail, its own budget implications, and its own set of rules.

​
The three kinds of delegation

There are three flavors of delegation, and they behave differently:
  1. Intra-team delegation: a manager agent hands a sub-task to one of its direct reports. This is the cheapest and most common form.
  2. Cross-team delegation: an agent in one team asks an agent in a different team to take on work. This requires a team-to-team interface agreement and shows up in both teams’ task boards.
  3. Human handoff: an agent decides the task needs a human and escalates. The task stops, waits for a human to pick it up, and resumes only when the human releases it back.
Each flavor has its own permission model, its own cost attribution, and its own default SLAs.

​
Intra-team delegation

When a manager agent breaks a task into sub-tasks and hands them to direct reports, the orchestrator does three things:
  • Creates a parent-child link between the original task and each sub-task
  • Copies the relevant context and memory scope down to the child
  • Opens a new budget envelope under the parent’s budget
The child tasks run independently. When they finish, their results roll up to the parent, and the parent agent decides whether the work is done or more sub-tasks are needed. A manager agent cannot delegate outside its own reporting chain. If the Head of Design wants the Head of Engineering to do something, that is not intra-team delegation, that is a cross-team handoff.

​
Cross-team delegation

Cross-team delegation is the riskiest form, because it crosses a budget boundary and a trust boundary at the same time. Before two teams can delegate to each other, they need an interface agreement: a small document that says what kinds of tasks team A can send to team B, what the expected turnaround is, and how costs are split. Interface agreements live at Company → Teams → Interfaces and are edited by the board operator (you). When a cross-team delegation happens:
  • The requesting team’s budget covers the task by default
  • The receiving team’s queue picks it up on its normal schedule
  • The receiving team’s agents follow their own memory and tool permissions, not the requesting team’s
  • Both teams see the task in their activity log, marked as cross-team
If you need a team to be able to pull work from another team without an interface agreement, you are probably looking at the wrong abstraction. Consider merging the teams or moving the agent.

​
Human handoff

Sometimes an agent needs a human. Approvals (see the next guide) are one form of this, but human handoff is broader: an agent can decide mid-task that it cannot proceed without a human and park the task. Reasons an agent might hand off:
  • A required credential is missing
  • The task is ambiguous and needs a decision
  • A tool returned an error the agent does not know how to handle
  • The agent hit a safety boundary (for example, attempting to spend more than its budget allows)
  • The agent’s own self-check flagged a risk it is not authorized to take
When an agent hands off, the task moves to a handoff queue scoped to the board operator or a designated human teammate. The task card shows exactly what the agent was doing, why it stopped, and what it needs from the human to resume. The human picks up the task, does whatever is needed, and releases the task back. On release, the agent resumes from the checkpoint it stopped at, with the human’s note added to its context. Handoffs never silently drop a task. If nobody picks up a handoff within the team’s SLA, the task escalates up the org chart.

​
Re-delegation

Once a task is in flight, the agent working on it can re-delegate to somebody else, but only under specific conditions:
  • The current agent must explicitly give up the task (no silent drops)
  • The new owner must be able to see the same task context
  • The budget envelope is transferred, not duplicated
Re-delegation is logged as a separate event in the activity log. If you find the same task bouncing between agents more than twice, that is a signal to either rewrite the task or pull it up to a human.

​
Delegation limits

To prevent runaway delegation chains (agent A delegates to B, B to C, C back to A), there is a hard cap on delegation depth, set per company under Settings → Safety → Delegation depth. The default is 5. Any attempt to go deeper is rejected by the orchestrator and surfaces as an escalation. There is also a per-task delegation count cap (default 10) so that a single task cannot be handed around forever.

​
Next

  • Approvals for the one form of handoff you will see most often.
  • Costs and budgets for how delegation affects the budget envelopes.
  • Activity log for how to trace delegation chains after the fact.