Composable by Design

Capabilities that layer, share, and delegate

The Frame

Most AI assistants are one big config; Amplifier makes capabilities composable instead

Tune one monolithic configuration in place and you can't layer, share, or delegate it. Amplifier splits mechanism from policy: capabilities become composable bundles over a tiny kernel of module protocols.

And that kernel is smaller and more countable than you'd expect.

# Two core repos hold the mechanism
microsoft/amplifier-core        # the kernel / protocols
microsoft/amplifier-foundation  # bundles + agents + delegate

Proof

The whole system rests on exactly six module protocols in one file

The kernel defines six @runtime_checkable Protocol interfaces in amplifier_core/interfaces.py. Modules implement them by structural subtyping — no inheritance required.

Six interfaces is the count. But the deeper choice is what the kernel refuses to do.

Orchestrator

Provider

Tool

ContextManager

HookHandler

ApprovalProvider

The Design Decision

The kernel ships mechanisms only, never policies

The core bundle.md states the kernel “provides MECHANISMS only, never POLICIES.” Orchestration, provider, and logging choices live in swappable modules, not the center.

That's why raw protocols alone still aren't something you can hand to a teammate.

“The center stays still so the edges can move fast.”
Litmus test: “Could two teams want different behavior? → policy → Module, not kernel.”
The kernel is documented as intentionally tiny (~2,600 lines).

The Gap

A bare protocol can't be layered, shared, or reused across teams.

Mechanisms are necessary — but they aren't yet a capability you can pass around. Something has to package them.

The Composition Mechanism

A bundle is a declarative file that pulls in other bundles

On top of the protocols, amplifier-foundation adds a bundle system: “One concept (bundle), one mechanism (includes: + compose()).” The foundation bundle composes 20 other bundles this way.

Once bundles compose, the reusable units they carry — like agents — become shareable too.

# bundle.md front-matter
includes:
  - foundation:behaviors/agents
  - git+.../amplifier-bundle-recipes@main
  # load + compose + validate + resolve

Meet the Agents

Agents are just markdown files — sixteen specialists already ship

Each agent is a markdown file with YAML frontmatter (meta, model_role, provider_preferences, tools) plus an instruction body. Sixteen reusable agents ship in amplifier-foundation/agents/.

These named specialists are exactly what the next move hands work to.

16

agents shipped in foundation/agents/

4

frontmatter fields per agent: meta, model_role, provider_preferences, tools

The Payoff

A composed session becomes “an ORCHESTRATOR, not a worker”

A first-class tool-delegate module (wired via behaviors/agents.yaml, v2.0.0) lets a session delegate real work to specialist agents — “Delegation is not optional — it is the PRIMARY operating mode.”

Composition stops being an architecture diagram and starts doing the work.

self_delegation — a session can spawn specialists
session_resume & context_inheritance (max_turns 10)
provider_selection per delegated agent
exclude_tools: [tool-delegate] — spawned agents don't re-delegate by default

Shipped & stable

Split mechanism from policy and everything above it becomes composable

Because the split holds, bundles are even polyglot — a module declares a python / rust / wasm / grpc transport in amplifier.toml. Downstream, a themed-bundles collection packages 15 archetype bundles to layer and share.

The center stays still; the edges — and the sharing — move fast.

python

rust

wasm

grpc

Sources

Research Methodology

Data as of: latest amplifier-core HEAD dated 2026-02-17.

Feature status: Kernel protocols, bundle composition, and agents/delegate are all shipped & stable in microsoft/amplifier-core and microsoft/amplifier-foundation.

Commands run:

Six protocols: grep -cE '^class .*\(Protocol\)' amplifier_core/interfaces.py → 6 (Orchestrator, Provider, Tool, ContextManager, HookHandler, ApprovalProvider)
Documented kernel size: grep -n '2,600' README.md bundle.md (README.md:7, bundle.md:18 — documented design claim, not a raw line count)
Composition: grep -c '^\s*- bundle:' bundle.md → 20; README.md:159 “includes: + compose()”
Agents: ls agents/*.md | wc -l → 16; frontmatter from head -40 agents/zen-architect.md
Delegate: cat behaviors/agents.yaml (tool-delegate, v2.0.0, max_turns 10, exclude_tools [tool-delegate])
Polyglot: head -60 context/POLYGLOT_BUNDLES.md (python/rust/wasm/grpc transports)
Timeline: git log -1 --format='%ad' --date=short → 2026-02-17; core initial commit f6d8ed6 (2025-10-08)
Contributors: git shortlog -sn HEAD

Gaps: “~2,600 lines” is the project's documented characterization; measured amplifier_core/*.py is 4,752 top-level / 8,134 full tree. The “monolith” contrast is authored narrative framing, not a repo quote.

Primary contributors: Brian Krabach (amplifier-core 130 commits; amplifier-foundation 470 commits), with Diego Colombo, Samuel Lee, Marc Goodner, Salil Das, Sam Schillace, and others.