Composition Model

Bundles & Agents

How Amplifier's composition system works

Active

February 2026

The Problem

AI assistants are monoliths

📦

Monolithic configs

One massive system prompt. Can't share pieces between projects. Can't compose capabilities from different teams.

📋

Copy-paste sharing

Want someone else's tools? Copy their config. Updates diverge immediately. No versioning, no composition.

🤖

Static agents

One agent, one personality, one skill set. No specialization. No delegation. No way to divide and conquer.

Bundles

Composable configuration packages

            A bundle combines modules (providers, tools, hooks), context files (instructions, knowledge), and agent definitions into a reusable, version-controlled package.
        

→ Configuration, not code — Markdown + YAML frontmatter
→ Can include other bundles — composition all the way down
→ Install from Git URLs, local paths, or registry
→ Version controlled and shareable like code

Design Principle

Bundles compose, they don't implement

✓ Good Bundle

Includes foundation bundle, adds context files, defines agent personas. Pure composition — YAML and markdown only.

✗ Bad Bundle

Implements Python code, duplicates module functionality. That's a module's job, not a bundle's.

            The test: If it has Python code implementing capabilities, it's a module. If it's YAML/markdown composing capabilities, it's a bundle.
        

Anatomy

What's inside a bundle?

# bundle.md — YAML frontmatter + markdown body
bundle:
  name: my-bundle
  version: 1.0.0
  description: What this bundle provides

includes:
  - bundle: foundation           # include other bundles
  - bundle: my-bundle:behaviors/main

# Markdown body = instructions for the agent
@my-bundle:context/instructions.md
@foundation:context/common-system-base.md

my-bundle/
├── bundle.md           # main definition
├── context/            # knowledge files
│   └── instructions.md
├── agents/             # agent definitions
│   └── specialist.md
└── behaviors/          # behavior compositions
    └── main.yaml

Architecture

Six kernel protocols

Orchestrator

Runs the agent loop

1 module

Provider

LLM backends

6 modules

Tool

Agent capabilities

7 modules

ContextManager

Memory & context

1 module

HookHandler

Lifecycle events

6 modules

ApprovalProvider

Human-in-the-loop

1 module

            Bundles compose over these protocols. Any module implementing a protocol can be swapped in. 22 modules implement the 6 protocols today — from amplifier_core/interfaces.py.
        

Agents

Agents are bundles with personas

            Key insight: Agents use the same file format as bundles — markdown + YAML. The difference: meta: frontmatter instead of bundle:, making them configuration overlays for specialized tasks.
        

# agents/zen-architect.md
meta:
  name: zen-architect
  description: Code planning and architecture specialist

# Zen Architect Instructions
You embody ruthless simplicity.
Analyze before implementing.
Design before building...

Agent Mechanics

Session spawning via delegate

Parent Session

↓ delegate tool

Child Session (Agent)

↓ returns result

Parent Resumes

→ Child runs its own orchestrator loop with agent context
→ Inherits context from parent (configurable depth + scope)
→ Returns a single result message — context conservation
→ Linked via parent_id for full session tracing

Ecosystem Today

Composition in practice

48

Packages in cache

93

Agent definition files

45

Behavior compositions

107

Context files

            22 modules implementing 6 kernel protocols, composed into 18+ bundles and ~62 unique agents. All counts from find ~/.amplifier/cache.
        

Foundation Library

16 agents in amplifier-foundation

zen-architect

Analysis-first design. Creates specs for the builder.

modular-builder

Implementation from specs. Won't guess — requires contracts.

explorer

Deep codebase reconnaissance. Surveys systematically.

bug-hunter

Hypothesis-driven debugging. Finds root causes.

git-ops

Git + GitHub with safety protocols and quality commits.

security-guardian

OWASP Top 10, secrets detection, pre-deploy checkpoint.

Plus: file-ops, session-analyst, test-coverage, web-research, integration-specialist, ecosystem-expert, foundation-expert, post-task-cleanup, amplifier-smoke-test, shell-exec

Sources

Research Methodology

Data as of: February 20, 2026

Feature status: Active

Research performed:

find ~/.amplifier/cache -name "*.md" -path "*/agents/*" | wc -l → 93 files
find ~/.amplifier/cache -maxdepth 1 -type d | wc -l → 49 (48 packages + root)
find ~/.amplifier/cache -name "*.yaml" -path "*/behaviors/*" | wc -l → 45 files
find ~/.amplifier/cache -name "*.md" -path "*/context/*" | wc -l → 107 files
grep "class.*Protocol" amplifier_core/interfaces.py → 6 protocols
cat amplifier-foundation/bundle.md → verified includes structure

Gaps: Agent count (93) includes ~13 test fixtures, node_modules entries, and duplicates from cache hashes. Estimated ~62 unique functional agents. Package count includes both bundle and module packages.

Primary repositories: microsoft/amplifier-core, microsoft/amplifier-foundation

Build your own

Start with foundation. Compose your capabilities.

Tutorial: ramparte.github.io/amplifier-tutorial
Foundation: github.com/microsoft/amplifier-foundation
Core: github.com/microsoft/amplifier-core