New Capabilities

AGENTS Behavior Bundle

From escape hatch to orchestration primitive.
Delegation reimagined.

Active
January 2026
The Paradigm Shift

Delegation Reimagined

"The difference between a contractor who subcontracts because they're overwhelmed versus an architect who assembles a team of specialists because each brings unique expertise."

Before: task
A survival mechanism. Delegate because you have to. Context got too large. Offload the overflow.
After: delegate
A first-class orchestration decision. Choose the right expert with the right context for the right job.
1 Pillar One

Self-Delegation

"Fresh mind for focused work"

delegate(
  agent="self",
  task="Analyze this module for performance issues"
)
🎯
Focused Subtasks
Spawn a clean instance without accumulated noise. The subtask sees only what it needs.
🔀
Parallel Exploration
Try multiple approaches simultaneously. Compare results. Pick the winner.
💾
Context Conservation
The parent session stays lean. Delegate the deep dives, keep the overview.
💡 Sometimes the best expert is yourself—just with a clear desk.
2 Pillar Two

Two-Vector Context Control

"Precision in what you share"

Scope: What's Included
conversation — User/assistant messages only
agents — + results from other agents
full — + all tool results
Depth: How Much
none — Clean slate
recent — Last N turns
all — Full history
delegate(
  agent="code-reviewer",
  context_scope="conversation",  # Just the discussion
  context_depth="recent"          # Last few turns only
)
💡 Context isn't binary. Different tasks need different slices of information.
The Context Matrix

Scope × Depth = Precision

Six combinations to match any delegation scenario.

none recent all
conversation Fresh start, task only Recent discussion context Full conversation history
agents Clean + agent coordination Recent + agent results Full + all agent work
full Clean + everything typed Recent + all tool outputs Complete session state
🎛️ Match context to task requirements. A code review needs different context than a security audit.
3 Pillar Three

Intelligent Delegation

"Know your team, coordinate them"

🔍
Discovery
Agents are discoverable. Query what specialists exist and what they do before delegating.
list_agents()
⚡
Parallel Dispatch
Multiple agents work simultaneously. Coordinate specialists on different aspects of a problem.
delegate([a, b, c])
🔄
Session Resume
Continue multi-turn conversations with agents. Build on previous work instead of starting fresh.
session_id="..."
💡 Effective delegation requires knowing your options, coordinating specialists, and maintaining relationships.
Why It Matters

Before & After

Before
After
"I asked and got a wrong answer"
Agent discovery → Right expert, first time
"My session fills up and forgets"
Self-delegation → Context stays clean
"I can't coordinate multiple agents"
Parallel + resume → True multi-agent workflows
"Delegated tasks get confused"
Two-vector context → Precise information sharing
🚀 The unlock: Think in terms of team composition rather than context management.
Design Philosophy

Built on Principles

Capability vs Selection
The delegate tool provides capability to orchestrate. Agent selection is the caller's responsibility.
Simple. Predictable. Flexible.
The Context Sink Pattern
Bundles without agent behaviors have zero agent knowledge. Agent capabilities are explicitly opt-in.
No surprise behaviors.
Composable Behaviors
Agent capabilities compose via bundles. Want delegation? Add the agents behavior. Gradual rollout, isolation.
Incremental adoption.
Patterns

What You Can Build

Pattern
Deep Analysis
delegate( agent="self", task="Audit security", context_depth="none" )
Pattern
Specialist Handoff
delegate( agent="code-reviewer", context_scope="agents" )
Pattern
Parallel Explore
delegate([ {agent: "a", task: "..."}, {agent: "b", task: "..."} ])
Pattern
Iterative Refinement
delegate( agent="writer", session_id=prev_session )
Pattern
Context Snapshot
delegate( agent="self", context_scope="full", context_depth="all" )
Pattern
Clean Handoff
delegate( agent="specialist", context_depth="none" )
The Value Proposition

A New Mental Model

Before
Delegation was about
managing limitations
→
After
Delegation is about
leveraging expertise

Stop thinking about context windows. Start thinking about team composition.

Summary

Three Pillars of
Modern Delegation

1
Self-Delegation
Fresh mind, focused work
2
Two-Vector Context
Scope × Depth precision
3
Intelligent Delegation
Discover, dispatch, resume

From escape hatch to orchestration primitive.

Sources & Methodology

Research & Attribution

Data as of
February 20, 2026
Feature Status
Active — Part of amplifier-foundation, actively used in production
Research Performed
Foundation agents behavior analysis via ~/.amplifier/cache/amplifier-foundation-*/
Context files: delegation-instructions.md, multi-agent-patterns.md, session-storage-knowledge.md
Agents Analyzed (16)
web-research git-ops file-ops explorer ecosystem-expert shell-exec amplifier-smoke-test session-analyst foundation-expert zen-architect security-guardian bug-hunter post-task-cleanup test-coverage modular-builder integration-specialist
Known Gaps
Usage analytics not yet available. Performance benchmarks pending.
Primary Contributors
Sam Schillace (primary architect), team contributors
Get Started

Try It Today

Add the agents behavior to your bundle and start orchestrating.

# In your bundle.yaml
behaviors:
  - agents

# Then delegate with precision
delegate(
  agent="specialist",
  task="Your focused task here",
  context_scope="conversation",
  context_depth="recent"
)
Agents Behavior Delegation Patterns
github.com/microsoft/amplifier-foundation
More Amplifier Stories