A Kernel for Agents

Amplifier's Linux-style mechanism/policy split

The Frame

Amplifier is a modular AI-agent system built around an ultra-thin kernel

Following the Linux kernel model, it keeps a tiny, stable center and pushes every feature to replaceable modules at the edges — so a team can shape agent behavior without forking one giant codebase.

And the center really is tiny — here's how tiny.

Kernel

amplifier-core
the stable center

Modules

userspace — swappable
features at the edges

Proof — Measured, Not Marketing

The whole kernel is just 8,134 lines of Python

The amplifier_core package spans 40 Python files and pulls in only 5 runtime dependencies — click, pydantic, pyyaml, tomli and typing-extensions.

A center this small didn't start small — it was carved out.

8,134

lines of Python in the kernel

40

Python files in the package

5

runtime dependencies

The Tension

This kernel was literally extracted from a monorepo

The very first commit — f6d8ed6, on 2025-10-08 by Brian Krabach — is titled "Extract amplifier-core from monorepo." A single shared codebase is exactly the problem it was escaping: where any change risks breaking everyone.

So what gets to live in the kernel — and what gets pushed out?

$ git log --reverse --format='%h %ai %an %s' | head -1 f6d8ed6 2025-10-08 Brian Krabach Initial commit: Extract amplifier-core from monorepo

Mechanism, Not Policy

The kernel ships only mechanism; every policy is pushed out to modules

The one dividing line: the kernel provides module loading, lifecycle coordination, events and session management. Which modules to load, what to log, orchestration strategy and security policy all live in modules.

But if policy lives outside, how do modules plug in cleanly?

Kernel = Mechanism

Module loading
Lifecycle coordination
Hook system & events
Session management

Modules = Policy

Which modules to load
What to log
Orchestration strategy
Security policy

The Studs

Six Python Protocols define the stable contracts between kernel and modules

Defined in interfaces.py using structural typing — no inheritance required. A module just has to match the shape, which is what makes the edges swappable without coupling to the center.

And the kernel works surprisingly hard to keep those contracts honest.

Orchestrator Provider Tool ContextManager HookHandler ApprovalProvider

The Turn

Nearly 40% of the kernel does nothing but validate those contracts

The contract-validation subsystem is 3,286 lines — about 40% of the whole kernel. The boring center spends its bulk protecting the boundary, not piling on features, so the edges can keep moving.

That protected boundary is what buys everyone independent movement.

3,286

lines of contract validation

~40%

of the kernel, guarding the boundary

The Payoff

The kernel barely changes while modules and bundles evolve in parallel

Across ~4.3 months the kernel took 134 commits from just 5 authors. Meanwhile ~11 module repos and 29 bundle repos evolve independently — teams build their own behavior without ever touching the center.

That split is a pattern worth stealing.

~11

module repos evolving independently

29

bundle repos composing modules

134

kernel commits in ~4.3 months

The Takeaway

Keep the shared center small and boring; push innovation to replaceable edges

That's how many teams share one foundation: a tiny kernel of pure mechanism holds still, while policy lives in modules that any team can swap — the same split Linux used to let userspace innovate on a stable core.

Sources

Research Methodology

KERNEL STATUS: ACTIVE / MAINTAINED

Primary source: amplifier-core (local: ~/dev/ANext/amplifier-core; origin=ramparte/amplifier-core fork, upstream=microsoft/amplifier-core), measured at HEAD 5249084.

Data as of: latest kernel commit 2026-02-17 (5249084, Sam Schillace).

Commands run:

Kernel LOC: find amplifier_core -name '*.py' | xargs wc -l | tail -1 → 8134 total
File count: find amplifier_core -name '*.py' | wc -l → 40
Protocols: grep -n 'class.*Protocol' amplifier_core/interfaces.py → 6 module-type protocols
Validation LOC: find amplifier_core/validation -name '*.py' | xargs wc -l | tail -1 → 3286 total
Dependencies: grep -A15 'dependencies' pyproject.toml → 5 runtime deps
First commit: git log --reverse --format='%h %ai %an %s' | head -1 → f6d8ed6 (Extract from monorepo)
Commit count / authors: git rev-list --count HEAD → 134; git log --format='%an' | sort -u → 5 authors
Module & bundle repos: ls -d amplifier-module-*/ | wc -l (~11 live); ls -d amplifier-bundle-*/ | wc -l → 29

Gaps: "~11" modules reflects 12 local directories minus one stale duplicate (amplifier-module-provider-anthropic.broken). The README's "~2,600 lines" figure is stale; the measured 8,134 is used. "N teams" is not a measured count — module/bundle repo counts are proxies.

Primary contributors: Brian Krabach (initial extraction and most early kernel commits); kernel authors also include Diego Colombo, Marc Goodner, Sam Schillace, Samuel Lee.