Skip to content

Ecosystem

The Amplifier ecosystem consists of modular components that combine to create AI agent systems. This page provides an overview of the ecosystem structure and available components.

Ecosystem Layers

┌─────────────────────────────────────────────┐
│  Applications                               │
│  User-facing apps that compose capabilities │
└─────────────────┬───────────────────────────┘
                  │
┌─────────────────▼───────────────────────────┐
│  Bundles                                    │
│  Composable configuration packages          │
└─────────────────┬───────────────────────────┘
                  │
┌─────────────────▼───────────────────────────┐
│  Runtime Modules                            │
│  Providers, Tools, Orchestrators, Hooks     │
└─────────────────┬───────────────────────────┘
                  │
┌─────────────────▼───────────────────────────┐
│  Kernel (amplifier-core)                    │
│  Ultra-thin kernel providing mechanisms     │
└─────────────────────────────────────────────┘

Core Components

Kernel

The foundational layer that provides module loading, event emission, and coordination.

Component Description Repository
amplifier-core Ultra-thin kernel for modular AI agent system amplifier-core

Applications

User-facing applications that compose libraries and modules.

Component Description Repository
amplifier Main project - installs amplifier-app-cli via uv tool install amplifier
amplifier-app-cli Reference CLI application amplifier-app-cli

Libraries

Foundational libraries used by applications (not used directly by runtime modules).

Component Description Repository
amplifier-foundation Foundational library for bundles, module resolution, and shared utilities amplifier-foundation

Architectural Boundary: Libraries are consumed by applications. Runtime modules only depend on amplifier-core.

Runtime Modules

Runtime modules implement specific capabilities and are loaded dynamically based on configuration.

Module Types

  • Providers - LLM backend integrations (Anthropic, OpenAI, Gemini, etc.)
  • Tools - Agent capabilities (filesystem, bash, web, etc.)
  • Orchestrators - Execution loop strategies (basic, streaming, events)
  • Contexts - Memory management (simple, persistent)
  • Hooks - Observability and control (logging, approval, redaction, etc.)

See the full module catalog for complete listings of:

  • Official runtime modules (providers, tools, orchestrators, contexts, hooks)
  • Bundles (recipes, browser-tester, design-intelligence, python-dev, etc.)
  • Community applications and bundles
  • Community modules

Bundles

Composable configuration packages that combine providers, behaviors, agents, and context into reusable units.

Bundles enable:

  • Reusable configurations - Pre-configured setups for common use cases
  • Behavior composition - Combine multiple capabilities
  • Agent libraries - Collections of specialized agents
  • Context resources - Skills, prompts, and knowledge bases

Using Bundles

# Add a bundle to the registry
amplifier bundle add git+https://github.com/microsoft/amplifier-bundle-recipes@main

# Use a bundle
amplifier bundle use recipes

# Check for updates
amplifier bundle update --check

See the Bundle Guide for creating your own bundles.

Module Discovery

Modules are discovered via:

  1. Python Entry Points - Standard entry points in pyproject.toml
  2. Environment Variables - AMPLIFIER_MODULES=/path/to/modules
  3. Explicit Search Paths - ModuleLoader(search_paths=[...])

Module Contracts

All modules implement standard protocols:

Module Type Required Interface Purpose
Provider complete(), parse_tool_calls(), get_info() LLM backends
Tool name, description, input_schema, execute() Agent actions
Orchestrator execute() Execution loops
Context add_message(), get_messages(), compact() Memory
Hook __call__(event, data) -> HookResult Observability

See Module Contracts for detailed specifications.

Community Contributions

The Amplifier community builds:

  • Applications - Domain-specific UIs and tools
  • Bundles - Specialized capability packages
  • Modules - Custom providers, tools, and hooks

SECURITY WARNING: Community components execute arbitrary code in your environment with full access to your filesystem, network, and credentials. Only use components from sources you trust. Review code before installation.

See the full community catalog for:

  • Community applications
  • Community bundles
  • Community modules (providers, tools, hooks)

Building Components

Amplifier can help you build Amplifier components! See:

Module Source Resolution

Modules can come from:

  • Git repositories - git+https://github.com/org/repo@branch
  • Local paths - /path/to/module
  • Python packages - amplifier-module-tool-bash

The ModuleSourceResolver handles flexible module sourcing.

Next Steps