Amplifier Composition

14 Lines
to Infinity

The composition model that makes AI agents as simple as YAML
and as powerful as your imagination

Active February 2026
The Miracle

14 lines. One complete AI assistant.

bundle.md
 1---
 2bundle:
 3  name: recipe-author
 4  version: 1.0.0
 5  description: Conversational recipe expert
 6
 7includes:
 8  - bundle: git+https://...amplifier-foundation@main
 9  - bundle: foundation:behaviors/recipes
10  - bundle: foundation:behaviors/amplifier-dev
11
12context:
13  - path: instructions.md
14---
Identity · lines 2–5

Name, version, purpose — who this agent is

Composition · lines 7–10

Foundation + two behaviors. Three lines that inherit 50+ agents, 10+ tools, 15+ hooks, and 8 providers

Instructions · lines 12–13

Custom context — the markdown body below the frontmatter is the system prompt. This line adds more.

The markdown body below line 14 becomes the agent's instruction. That's a production-ready AI assistant.
The Pattern

The power is in what's absent

What you declare

  • bundle name
  • version
  • description
  • includes: [foundation]
  • context: [instructions]
5 declarations

What you inherit

50+ agents 10+ tools 15+ hooks 8 providers streaming UI session management security & redaction progress monitoring multi-step recipes code navigation browser testing design intelligence git operations web research container orchestration LSP integration
This isn't laziness — it's dependency inversion. Thin bundles trust foundation to provide the runtime substrate. They declare only what's uniquely theirs.
Composition

includes: not configures:

Instead of hundreds of config flags, Amplifier uses includes: chains. Each behavior is a composable capability. Snap them together like crystalline bonds.

⚡

agents.yaml

Delegation with context inheritance, session resume, self-delegation, and provider selection

📡

streaming-ui.yaml

Live terminal rendering of thinking blocks, tool calls, and token usage display

📋

recipes.yaml

Multi-step workflows with approval gates, foreach loops, and automatic checkpointing

✅

todo-reminder.yaml

Progress tracking with visual bar and analysis-paralysis detection after 30 reads

Each behavior bundles agents + context + tools into a single includes: line. No merge conflicts. Just additive composition.
Behaviors

The unit of reuse

A behavior packages one capability — tools, hooks, agents, context, or any combination — into a composable unit. Anyone can include your behavior without inheriting your entire configuration.

behaviors/todo-reminder.yaml
bundle:
  name: behavior-todo-reminder

tools:
  - module: tool-todo

hooks:
  - module: hooks-todo-reminder
  - module: hooks-todo-display
1 tool

The tool-todo module gives agents the ability to create and manage task lists

2 hooks

One hook reminds the agent about pending tasks. The other renders a visual progress bar in the terminal.

1 include line

Any bundle gets all three by adding one line:
- bundle: foundation:behaviors/todo-reminder

The Model

Every brick does one thing

Foundation bricks

streaming-ui
Live display · hook
agents
Delegation · tool
sessions
Lifecycle · composite
redaction
Security · hook
todo-reminder
Progress · tool + hooks
status-context
Environment · hook

Ecosystem bricks

recipes
Workflows · tool + agents
design-intelligence
Design system · agents
python-dev
Code quality · tool + agents
browser-tester
UI testing · agents
shadow
Isolated envs · tool + agents
skills
Knowledge · tool
Composition is additive. Each brick provides one thing cleanly. No merge conflicts. No side effects. Just capability accrual.
Unification

Agents are bundles

Same file format. Same tools: section. Same composition rules. An agent is a bundle with meta: instead of bundle: — loaded into a spawn context instead of the root session.

bundle.md
---
bundle:
  name: recipe-author
  version: 1.0.0

includes:
  - bundle: foundation

tools:
  - module: tool-recipes
---
agents/bug-hunter.md
---
meta:
  name: bug-hunter
  description: "Debugging expert"

tools:
  - module: tool-filesystem
  - module: tool-bash
  - module: tool-lsp
---
Agents include behaviors. Agents declare tools. Agents configure providers. The same composition model, all the way down.
The Chain

From YAML to running session

Each layer adds exactly what it owns. Nothing bleeds across boundaries.

1 Protocols Kernel contracts define module types
2 Foundation Assembles the base runtime substrate
3 Behaviors Package capabilities for reuse
4 Bundle Composes foundation + behaviors
5 App Layer Injects secrets & preferences
6 Mount Plan Flat dict — the kernel contract
7 Session Mounts modules in fixed order

Resolution is parallel. Includes are loaded via asyncio.gather() with diamond deduplication and circular-reference detection.

Mount order is fixed. Orchestrator → Context → Providers → Tools → Hooks. Each loader.load() returns a mount function registered on the ModuleCoordinator.

The Ecosystem

All text files. All composable. All yours.

29
Bundles
22 first-party · 7 community
50+
Agents
18 local · 30+ remote
19
Behaviors
12 in foundation · 7 in ecosystem
17
Tools
10 first-party · 7 community
17
Hooks
15 first-party · 2 community
11
Providers
8 first-party · 3 community
Every module is a text file you can read, diff, review, and compose. No black boxes. No lock-in.
Sources

Research Methodology

Data as of: February 26, 2026

Feature status: Active — core composition model powering all Amplifier sessions

Research performed:

Gaps:

Primary repository: microsoft/amplifier-foundation (composition engine), microsoft/amplifier-core (kernel)

In design systems, tokens compose into components compose into patterns compose into experiences. In Amplifier, protocols compose into modules compose into behaviors compose into agents.

The composition is the architecture.

The Amplifier Design Philosophy
Try it github.com/microsoft/amplifier-foundation
More Amplifier Stories