One Concept, One Mechanism

Amplifier's ultra-thin bundle layer

What Amplifier Is

One thin layer everything else composes on.

Amplifier is Microsoft's modular framework for building AI agent apps. amplifier-foundation is its foundational library — an ultra-thin mechanism layer for bundle composition that every app builds on top of.

The question this deck answers: how does one thin layer assemble a whole agent app?

Not a Sketch

This is a live, seriously-developed library.

Since its initial import on 2025-12-09, amplifier-foundation has grown to 502 commits, current through 2026-04-09 — built out of Microsoft's MADE:Explorations Team.

So the foundation is real. What problem is it built to solve?

502

commits since initial import

~94%

by Brian Krabach (470 / 502)

MIT

license · MADE:Explorations Team

Why Assembly Gets Hard

Wiring a session tempts you to bake in policy.

An agent app has to assemble providers, tools, agents, and hooks into one working session. The tempting shortcut is to bake decisions into the framework itself — and foundation is deliberately built the other way: pure mechanism, not policy.

So what is the single unit foundation uses instead?

The One Concept

There is exactly one concept: the Bundle.

A Bundle is a composable markdown-with-YAML-frontmatter configuration that declares a session's providers, tools, agents, and hooks — one unit for the whole assembly problem.

One concept needs one mechanism to turn it into a running app.

# bundle.md — one composable unit
bundle:
  name: foundation
  version: 2.0.0

# declares for the session:
providers:  # LLM backends
tools:
agents:
hooks:

The One Mechanism

Bundles compose — later overrides earlier.

One rule drives everything: base.compose(overlay), where later overrides earlier. The composed Bundle then produces a mount plan that runs as an AmplifierSession.

One concept, one mechanism — so what does the library actually ship?

1

compose — base.compose(overlay), later overrides earlier

2

to_mount_plan() — the Bundle produces a Mount Plan

3

AmplifierSession — the mount plan runs as a session

Mechanism, Not Policy

The library ships reference content — loaded like any bundle.

Foundation stays pure mechanism: it ships reference providers, agents, and examples, and the app loads them like any other bundle. The app, not the library, decides policy.

If the mechanism is this thin, can it handle a genuinely hard problem?

5

reference providers

16

reusable agents

20

runnable examples

The Payoff

The delegate tool proves the one mechanism scales.

The foundation bundle (v2.0.0) adds a delegate tool for a genuinely hard problem — agent orchestration — with no new concept. It gives fine-grained control from just two parameters: context_depth × context_scope.

The same compose model handled it — that's the whole bet.

context_depth — none · recent · all
HOW MUCH to inherit
context_scope — conversation · agents · full
WHICH content to include

The Whole Bet

One concept, one mechanism — thin while doing more.

Ruthless simplicity is the leverage: collapse assembly to a single Bundle and a single compose rule, and the same model reaches from "hello world" to fine-grained agent orchestration without ever growing a second concept.

That is what lets Amplifier stay thin while doing more.

Sources

Research Methodology

Source repo: git@github.com:microsoft/amplifier-foundation.git (confirmed via git remote -v — origin = microsoft/amplifier-foundation; sibling core repos point to ramparte/* forks).

Data as of: local checkout current through 2026-04-09 · Status: Python package v1.0.0 (Development Status :: 4 — Beta), MIT · foundation bundle v2.0.0.

Research performed (local git + file inspection):

git rev-list --count HEAD → 502 commits
git log --reverse --format='%ci|%an|%s' → 2025-12-09 initial import (Brian Krabach)
git log -1 --format='%ci|%an|%s' → 2026-04-09 latest commit (Sam Schillace)
git shortlog -sne HEAD → Brian Krabach 470/502 (~94%)
ls providers/*.yaml | wc -l → 5 · ls agents/*.md | wc -l → 16 · ls examples/*.py | wc -l → 20
head README.md, grep pyproject.toml, head bundle.md, head docs/CONCEPTS.md → description, authors, license, delegate tool, compose flow

Gaps: No gh calls run — PR/issue history and star counts not queried; all metrics derive from local git and file inspection. The top-level microsoft/amplifier repo is not checked out locally; no claims made from it. README says "20+" examples; exactly 20 numbered files found.

Primary contributor: Brian Krabach — 470 of 502 commits (~94%; original author of the initial import).