Compose a Team

delegation as an orchestration primitive

The Problem

Long agent sessions degrade because direct work floods the context window

Amplifier's "agents" behavior fixes that: instead of doing all the work yourself, you hand it to specialists and stay lean.

And the handoff isn't vague — it's a real, tunable primitive.

~20,000

tokens in YOUR context for 20 direct file reads

~500

tokens (summary only) when the same 20 reads are delegated

Proof — in the code

Precise handoffs are real: two independent context parameters

The delegate tool takes context_depth (how much) and context_scope (which content) — three enum values each, confirmed in the source.

This precision ships as one composable bundle.

context_depthnone / recent / all
context_scopeconversation / agents / full
defaultsdepth=recent (5 turns), scope=conversation

The AGENTS behavior

It all ships as one opt-in, composable bundle

behavior-agents v2.0.0 packages the delegate tool plus delegation context. Bundles that omit it have zero knowledge agents even exist.

So why was delegation ever a second-class idea?

behavior-agents v2.0.0one opt-in composable include (bundle.md line 27)
tool-delegateone delegate tool packaged by the bundle
+ delegation contextdelegation-instructions.md & multi-agent-patterns.md

The old framing

Delegation used to be a survival hatch

The legacy behavior-tasks v1.0.0 offloaded work mainly to stop the parent context overflowing — a defensive move about token survival, not orchestration.

The v2.0.0 behavior flips that motive on its head.

v1.0.0

behavior-tasks (legacy tool-task) — kept for backwards compatibility

v2.0.0

behavior-agents (new tool-delegate) — recommended for new development

Mechanism — self-delegation

Hand work to a fresh sub-instance while the root stays lean

Self-delegation (agent="self") is on by default and guarded by a recursion limit (max_depth=3), giving the work a fresh mind without polluting your session.

And you don't have to run one specialist at a time.

# fresh sub-instance, maximum token conservation
delegate(
  agent="self",
  context_depth="all",
  context_scope="full",
)
# enabled by default; max_depth = 3

Mechanism — parallel dispatch

Fire a whole team in a single message, then resume any one

Parallel dispatch is a documented pattern: multiple delegate calls in one message with context_depth="none" run independent specialists at once. Each returns a session_id to resume.

Discover, dispatch, resume — that's orchestration.

# parallel dispatch - independent surveys
delegate(agent="explorer", context_depth="none")
delegate(agent="explorer", context_depth="none")
delegate(agent="explorer", context_depth="none")
# resume later:
delegate(session_id=result.session_id, ...)

The flip

"You are an ORCHESTRATOR, not a worker."

Pick from foundation's 16 specialist agents and compose a team. Delegation stays top-level by default — spawned agents set exclude_tools:[tool-delegate] and can't further delegate.

You think in team composition, not context windows.

16

specialist agent .md files in amplifier-foundation/agents/

top-level

exclude_tools:[tool-delegate] keeps delegation controlled

What to keep

From escape hatch to orchestration primitive

Three things the "agents" behavior gives you — carry these away.

Compose a team; don't manage a context window.

1 — Precise context slices

context_depth × context_scope (3 × 3 enum values)

2 — Parallel specialist dispatch

many delegate calls in one message (depth="none")

3 — Self-delegation + session resume

fresh sub-instance; resume by session_id

Sources

Research Methodology

Status: Shipped — active maintenance

Repository: amplifier-foundation (behaviors/agents.yaml + modules/tool-delegate)

Feature status: behavior-agents v2.0.0, included by default in the foundation bundle; tool-delegate recommended over legacy tool-task (behavior-tasks v1.0.0).

Research performed:

cat behaviors/agents.yaml — bundle name / version / tools / context
sed -n '275,295p' modules/tool-delegate/amplifier_module_tool_delegate/__init__.py — context_depth / context_scope enums
sed -n '710,712p' __init__.py — defaults (depth=recent, turns=5, scope=conversation)
sed -n '108,110p' __init__.py — self_delegation enabled, max_depth=3
grep -n 'session_id' __init__.py — session resume path
grep -n 'Parallel Agent Dispatch' context/agents/multi-agent-patterns.md — parallel dispatch pattern
ls amplifier-foundation/agents/*.md | wc -l — 16 specialist agents
grep -n 'exclude_tools' behaviors/agents.yaml — spawned agents can't further delegate
Timeline / contributors: git log --format='%an' -- behaviors/agents.yaml modules/tool-delegate

Primary contributor: Brian Krabach (35 commits to agents behavior & tool-delegate); Salil Das (PR #93).

Gaps: tool-delegate __init__.py (1286 lines) was not read line-by-line; "six precise context slices" is narrative framing (code has 3 depth × 3 scope = 9 combinations); "confused results" is narrative characterization of the legacy era, not repo text.