Skip to content
/
Tier A A8 Cross-runtime harness

Amplifier (microsoft)

amplifier · microsoft/amplifier · ★ 3.1k · last commit 2026-05-20

Ultra-thin Python kernel (~2,600 lines) with formal module protocol contracts and a Git-based bundle marketplace, providing a Linux-kernel-style extensible AI assistant platform.

Best whenThe kernel should only provide mechanisms — all intelligence lives in userland bundles. Bundling value in the main repo is premature optimization.
Skip ifBundling all capability in the core kernel, Prematurely freezing kernel design
vs seeds
agent-os(Archetype 4: methodology scaffold with no primitives) but amplifier adds a real Python runtime and formal module protoc…
Primitive shape 1 total
Subagents 1
00

Summary

Amplifier (Microsoft) — Summary

Amplifier is a modular AI development platform from Microsoft's MADE:Explorations team, published as a Python package installable via uv tool install. It ships with a single CLI binary (amplifier) and a bundle system where capability bundles are independently installable Git repositories containing agents, behaviors, and context documents. The core philosophy is an "ultra-thin kernel" (~2,600 lines of Python) that provides only mechanisms (sessions, modules, hooks, coordinators) while all intelligence lives in userland bundles. It supports 4 LLM providers at setup time (Anthropic, OpenAI, Azure OpenAI, Ollama) via an interactive wizard. The only bundled agent in the main repo is amplifier-expert, a knowledge-base consultant that must be consulted before implementing anything Amplifier-related. The project explicitly positions itself as a Linux-kernel analogy: "small, protected core paired with a diverse and experimental userland." Compared to seeds: closest to agent-os (methodology-doc + scaffold) in philosophy, but Amplifier adds a real Python runtime, module protocol contracts, and a bundle marketplace mechanism absent from agent-os; it diverges from claude-flow by being provider-agnostic, CLI-native (not Claude-Code-specific), and kernel-based rather than MCP-toolserver-based.

01

Overview

Amplifier (Microsoft) — Overview

Origin

Microsoft MADE:Explorations Team. GitHub: https://github.com/microsoft/amplifier. Python package: amplifier. Version 0.1.0. Note: a previous Claude Code-based version exists on the amplifier-claude branch; the current main branch is provider-agnostic.

Philosophy

From the ROADMAP.md:

"Think of Amplifier like a Linux-kernel project: a small, protected core paired with a diverse and experimental userland."

"This project is a research demonstrator. It is in early development and may change significantly. Use it with caution, and at your own risk, we have NOT built in the safety systems yet."

The ROADMAP describes a metacognitive-recipe vision:

"Amplifier should evolve beyond being only a developer tool. As we continue to build support for metacognitive recipes — structured workflows described in natural language that are a mix of specific tasks and procedures but also higher-level philosophy, decision-making rationale, techniques for problem solving within the recipe's domain."

Key design choices

  1. Ultra-thin kernel (~2,600 lines): The kernel only provides Session, Coordinator, Mount Plan, and module lifecycle methods (mount(), on_session_ready()). Everything else is a module.
  2. Module protocols: Tool, Provider, Orchestrator, ContextManager, Hook — each a separate protocol contract in CONTRACTS.md
  3. Bundle system: Capability bundles are Git repositories installed via amplifier bundle add git+https://.... Bundles ship agents in Markdown format with YAML front matter plus optional YAML behavior files.
  4. Provider-agnostic setup wizard: 4 providers (Anthropic, OpenAI, Azure OpenAI, Ollama) configured via interactive amplifier init.
  5. Single currently-bundled agent (amplifier-expert): Must be consulted before any Amplifier implementation work — acts as a knowledge-gating agent.

Roadmap ambitions

  • Own agentic loop (currently depends on Claude Code or similar)
  • Multi-mode operation via manifests
  • Non-developer use via metacognitive recipes
  • Context sharing via Git or file shares
  • Session transcript mining for learning
02

Architecture

Amplifier (Microsoft) — Architecture

Distribution

  • Python package: amplifier (v0.1.0)
  • Install: uv tool install git+https://github.com/microsoft/amplifier
  • CLI binary: amplifier (from [project.scripts] in pyproject.toml)
  • Required runtime: Python >= 3.11, uv
  • Dependencies: amplifier-core>=1.0.10, amplifier-app-cli (Git source)

Core architecture (kernel)

The kernel (amplifier-core, ~2,600 lines) provides:

  • Session — execution context; modules mount onto sessions
  • Coordinator — infrastructure context with session_id, hooks, mount points
  • Mount Plan — config dict specifying which modules to load
  • Module protocols: Tool, Provider, Orchestrator, ContextManager, Hook
  • Module lifecycle: mount() → on_session_ready() (fired after all modules mount)

Bundle system

Bundles are Git repositories. Install command:

amplifier bundle add git+https://github.com/microsoft/amplifier-bundle-recipes@main
amplifier bundle add git+https://github.com/microsoft/amplifier-bundle-design-intelligence@main

A bundle ships:

  • agents/ — Markdown agent files with YAML front matter
  • behaviors/ — YAML behavior manifests referencing agents + context

Directory structure (repo)

agents/
  amplifier-expert.md      # YAML front matter + role description
behaviors/
  amplifier-expert.yaml    # Bundle definition referencing agent + context
context/                   # Contextual documentation
docs/                      # Architecture docs
recipes/                   # Workflow recipes
pyproject.toml             # Python package definition

Config

  • ~/.amplifier/config.yaml (written by amplifier init wizard)
  • Provider + model selection stored at init time

Target AI tools

Provider-agnostic: Anthropic Claude, OpenAI, Azure OpenAI, Ollama. Previously supported Claude Code (now moved to amplifier-claude branch).

03

Components

Amplifier (Microsoft) — Components

Agents (in main repo: 1)

Agent Purpose
amplifier-expert Authoritative consultant for Amplifier ecosystem — must be consulted before implementation, during planning, and for validation. Operates in RESEARCH, GUIDE, and VALIDATE modes.

Additional agents come via bundles:

  • recipes:recipe-author (from amplifier-bundle-recipes)
  • design-intelligence:component-designer (from amplifier-bundle-design-intelligence)

CLI commands

amplifier init          # First-time wizard (provider + model selection)
amplifier run "..."     # One-shot query
amplifier              # Start interactive chat mode
amplifier bundle add    # Install a capability bundle
amplifier bundle use    # Switch to a named bundle's context
/agents                 # In-chat: list available agents

Module protocols (kernel contracts)

Protocol Purpose
Tool Provide callable tools to sessions
Provider LLM backend (Anthropic, OpenAI, etc.)
Orchestrator Coordinate multi-step workflows
ContextManager Inject context into sessions
Hook Lifecycle event handlers

Behaviors (1 in repo)

behaviors/amplifier-expert.yaml:

bundle:
  name: amplifier-expert-behavior
  version: 1.0.0
agents:
  include:
    - amplifier:amplifier-expert
context:
  include:
    - amplifier:context/ecosystem-overview.md

No hooks (in repo)

The kernel supports hooks via the Hook protocol, but no hook implementations are bundled in the main repo. Hooks are a userland concern.

No MCP servers

The framework does not ship or require an MCP server. It has its own Python runtime + module system as the tool layer.

05

Prompts

Amplifier (Microsoft) — Prompt Excerpts

Excerpt 1: amplifier-expert agent description (YAML front matter)

Source: agents/amplifier-expert.md

---
meta:
  name: amplifier-expert
  description: "**THE authoritative consultant for ALL Amplifier ecosystem knowledge.**
    Use PROACTIVELY throughout the entire lifecycle: for initial research to understand
    what's possible, for guidance on how to build, and for validation of ideas/plans/
    implementations. This agent is the source of truth for amplifier-core, modules,
    amplifier-foundation, bundles, patterns, and best practices.

    **CRITICAL: Use this agent BEFORE implementation** to get accurate context. Use it
    DURING work to validate approaches. Use it AFTER to verify alignment with Amplifier
    philosophy."
  model_role: general
---

Prompting technique: Mandatory consultation gate — the CRITICAL: Use this agent BEFORE implementation instruction in the description field creates a pre-implementation knowledge gate. The model_role: general declares the agent's LLM slot without locking a specific model.

Excerpt 2: amplifier-expert operating modes

Source: agents/amplifier-expert.md (body)

## Operating Modes

### RESEARCH Mode (Start of any Amplifier work)
**When to activate**: Any question about "what is", "how does", "what can"

Provide structured context:
- What capabilities/patterns exist
- Where to find authoritative documentation
- Which examples demonstrate the concept
- How this fits into the broader architecture

### GUIDE Mode (Implementation planning)
**When to activate**: Questions about "how should I", "what pattern for"

Provide implementation guidance:
- Recommended patterns with rationale
- Specific examples to reference
- Anti-patterns to avoid
- Which other agents to delegate to for implementation

### VALIDATE Mode (Review and verification)
**When to activate**: "Is this right", "does this align", review requests

Provide validation:
- Philosophy alignment check
- Pattern compliance verification
- Specific issues and fixes
- Links to authoritative docs for justification

Prompting technique: Mode-dispatch pattern — natural language query intent ("what is" vs "how should I" vs "is this right") activates different response templates. The agent self-classifies the question type and switches mode accordingly.

09

Uniqueness

Amplifier (Microsoft) — Uniqueness & Positioning

Differs from seeds

Closest to agent-os in the "methodology + scaffold" archetype (Archetype 4 from seed-comparison), but Amplifier adds a real Python runtime and module protocol system where agent-os is purely markdown. Also resembles BMAD-METHOD in the "bundle of agents" model, but Amplifier's bundles are Git-installable Python packages rather than markdown persona files.

Key differentiators from all 11 seeds:

  1. Linux kernel analogy + module protocol contracts — the explicit CONTRACTS.md defining Tool, Provider, Orchestrator, ContextManager, Hook protocols with lifecycle methods (mount(), on_session_ready()) is the most principled extensibility architecture in the corpus. No seed defines formal module protocols.

  2. Bundle marketplace — capability bundles are independent Git repos (amplifier bundle add git+https://...), allowing a genuine decentralized ecosystem. Claude-flow has a plugin system but it's in the same repo; Amplifier bundles are first-class external artifacts.

  3. Provider-agnostic from the start — Anthropic, OpenAI, Azure OpenAI, Ollama all configured at init. The previous Claude Code integration was deliberately moved to a separate branch, suggesting intentional provider neutrality unlike most seeds.

  4. Microsoft provenance — the only framework in the batch from a major tech company. Research demonstrator status is explicit; safety systems are not yet built.

Observable failure modes

  • "Research demonstrator" status — explicit warning that it may change significantly and is not safe for production
  • Very thin main repo (1 agent, 1 behavior) — almost all value is in external bundles
  • Multi-agent orchestration not yet shipped (roadmap)
  • Windows known issues
  • Metacognitive recipe vision is ambitious but largely unimplemented

Competitive positioning

Amplifier is a platform play: the kernel is deliberately thin, betting that the ecosystem (bundles, community agents) creates the value. This is architecturally distinct from every other framework in the batch, which bundle all value in the main repo. Whether the ecosystem develops is the critical open question.

04

Workflow

Amplifier (Microsoft) — Workflow

Standard workflow

amplifier init         (first time: wizard selects provider + model)
amplifier run "task"   (one-shot) or amplifier (interactive)
→ session created
→ modules mount (provider, tools, orchestrator, context)
→ on_session_ready() fires for all modules
→ agent processes request
→ response streamed to terminal

Bundle-augmented workflow

amplifier bundle add git+https://...bundle-recipes@main
amplifier bundle use recipes
→ /agents     (list: recipes:recipe-author, ...)
→ recipes:recipe-author processes request with recipe-specific context

Metacognitive recipe workflow (described in ROADMAP, not yet fully implemented)

  1. Load recipe (structured workflow doc mixing tasks + philosophy)
  2. Agent follows recipe phases
  3. Human reviews/approves at defined checkpoints
  4. Lessons fed back into context for future sessions

Approval gates

Interactive chat mode allows natural human-in-the-loop; no explicit automated approval gates documented in the current implementation.

Phase artifacts

Phase Artifact
Init ~/.amplifier/config.yaml
Bundle install Bundle files in local bundle store
Session In-memory module state
Recipe run Output per-phase (TBD — roadmap)

TDD

Not enforced. The framework is at an early "research demonstrator" stage; TDD is not an explicit feature.

06

Memory Context

Amplifier (Microsoft) — Memory & Context

Session context

Context is managed via the ContextManager module protocol. The amplifier-expert agent gets @-mention access to live documentation across the entire Amplifier ecosystem at consultation time.

Persistent memory

Not documented in the main repo. The ROADMAP describes a vision:

"A prototype already exists for reconstructing transcripts and producing summaries to feed back into context."

Session transcript mining is a roadmap item, not a shipped feature.

Context sharing (roadmap)

"Team members should be able to share context without exposing private data publicly or merging into the public repository. Options include private Git repositories or shared OneDrive folders mounted as context."

A mount-based approach treating everything as files is described as the near-term target.

Bundle context

Bundles can inject context files via the context.include list in behavior YAML:

context:
  include:
    - amplifier:context/ecosystem-overview.md

This is the primary mechanism for loading domain knowledge into a session.

Compaction

Not documented. The framework is pre-1.0 and does not yet manage context window limits explicitly.

Cross-session handoff

Not implemented. Sessions are ephemeral; the ROADMAP notes transcript replay as future work.

07

Orchestration

Amplifier (Microsoft) — Orchestration

Pattern

Current state: sequential (single agent processes a request). The Orchestrator module protocol exists in the kernel contracts but multi-agent orchestration is listed in the ROADMAP as future work.

The ROADMAP mentions "Multi-Amplifier and modes" as a near-term goal:

"Amplifier should allow multiple configurations tailored to specific tasks. These 'modes' could be declared through manifests that specify which sub-agents, commands, hooks, and philosophy documents to load."

Multi-agent

No — single agent per session in current implementation. The kernel architecture supports orchestration via the Orchestrator protocol but no multi-agent implementation is shipped.

Subagent definition format

persona-md — agents are Markdown files with YAML front matter:

---
meta:
  name: amplifier-expert
  model_role: general
---
# Amplifier Expert
(role description body)

Isolation mechanism

None documented. Sessions share the same Python process.

Multi-model

Yes (at setup level) — 4 providers configurable via init wizard. However, within a session, one provider/model is active. No per-agent model routing.

Execution mode

interactive-loop — amplifier starts a chat loop. amplifier run "..." provides one-shot mode.

Crash recovery

No documentation. Research demonstrator status.

08

Ui Cli Surface

Amplifier (Microsoft) — UI & CLI Surface

CLI binary

Binary name: amplifier Entry: amplifier_app_cli.main:main Built with: Python Click (via amplifier-app-cli)

Commands:

  • amplifier init — first-time setup wizard (provider + model)
  • amplifier run "..." — one-shot query
  • amplifier — interactive chat mode
  • amplifier bundle add <url> — install capability bundle
  • amplifier bundle use <name> — activate a bundle's context
  • /agents (in-chat) — list available agents

Setup wizard flow:

Provider? [1] Anthropic [2] OpenAI [3] Azure OpenAI [4] Ollama: 1
API key: ••••••••
Model? [1] claude-sonnet-4-5 [2] claude-opus-4-6 [3] custom: 1
Ready! Starting chat...

Local UI

None. Terminal-only.

IDE integration

None documented in main branch. Claude Code integration was moved to amplifier-claude branch.

Observability

The ROADMAP mentions audit/replay and logging as a "Amplifier Kernel" roadmap item:

"small, protected core paired with a diverse and experimental userland... Amplifier Kernel providing interfaces for core features that may be central to all Amplifier experiences: capabilities, logging, audit/replay, storage, and memory rights."

Not yet shipped.

Platform support

macOS, Linux, WSL. Windows has known issues (README note).

Related frameworks

same archetype · same primary tool · same memory type

claude-mem (thedotmack) ★ 78k
A8 Cross-runtime harness

Background worker service captures every tool call as an observation, AI-compresses sessions, and auto-injects relevant past…

pi (badlogic/earendil) ★ 55k
A8 Cross-runtime harness

A minimal, hackable, multi-provider terminal coding agent that adapts to your workflows via npm-installable TypeScript Extensions…

Agent Skills (Addy Osmani) ★ 46k
A8 Cross-runtime harness

Encodes senior-engineer software development lifecycle as 23 auto-routed skills and 7 slash commands for any AI coding agent.

wshobson/agents Plugin Marketplace ★ 36k
A8 Cross-runtime harness

Single Markdown source for 83 domain-specialized plugins that auto-generates idiomatic artifacts for five AI coding harnesses.

TabbyML/Tabby ★ 34k
A8 Cross-runtime harness

Self-hosted AI coding assistant server (alternative to GitHub Copilot) with admin dashboard, RAG-based completions, and multi-IDE…

Compound Engineering ★ 17k
A8 Cross-runtime harness

Make each unit of engineering work compound into easier future work via brainstorm→plan→execute→review→learn cycles.