Skip to content

Contributing

Amplifier is an experimental platform with a multi-repository ecosystem. Contributing typically means creating your own repositories rather than submitting PRs to a monolithic codebase.

Understanding the Ecosystem

Amplifier's architecture is modular by design:

  • Core kernel (amplifier-core) - Small, stable, boring. High bar for changes.
  • CLI application (amplifier-app-cli) - Reference CLI for building and validating new capabilities. Not user-focused.
  • Reference implementations - Canonical examples for each module type and application pattern
  • Community ecosystem - Your own modules, tools, apps, and collections

Reference vs. Official

Current modules and apps are reference implementations, not "official" requirements. You can build alternatives, improvements, or entirely new capabilities. Users choose what to install based on their needs.

See the Showcase for examples of what the community has built.


Choose Your Contribution Type

Applications

Full CLI applications built on Amplifier's kernel and libraries.

Getting Started:

  1. Browse the Showcase for application examples
  2. Clone a reference app closest to your idea
  3. Study the structure and patterns
  4. Create your own repo: amplifier-app-yourname
  5. Build your application
  6. Publish and add back to the Showcase

Learn More: Developer Guide


Modules

Extend Amplifier's runtime capabilities. Modules are loaded dynamically based on profile configuration.

Providers

LLM backend integrations.

Reference Implementations: - provider-anthropic - provider-openai - provider-mock

Getting Started:

  1. Review the Provider Contract
  2. Clone a reference provider as template
  3. Implement the Provider protocol
  4. Test with the reference CLI
  5. Publish your provider module

Learn More: Provider Development


Tools

Agent capabilities like filesystem access, web browsing, code execution.

Reference Implementations: - tool-filesystem - tool-bash - tool-web

Getting Started:

  1. Review the Tool Contract
  2. Clone a reference tool as template
  3. Implement the Tool protocol
  4. Define your tool's schema
  5. Test with the reference CLI
  6. Publish your tool module

Learn More: Tool Development


Orchestrators

Execution loop strategies (basic, streaming, events).

Reference Implementations: - loop-basic - loop-streaming - loop-events

Getting Started:

  1. Review the Orchestrator Contract
  2. Study reference orchestrators
  3. Implement the Orchestrator protocol
  4. Test with various tool combinations
  5. Publish your orchestrator module

Learn More: Orchestrator Development


Contexts

Memory management strategies (simple, persistent, semantic).

Reference Implementations: - context-simple

Getting Started:

  1. Review the Context Contract
  2. Study the reference context
  3. Implement the ContextManager protocol
  4. Test compaction strategies
  5. Publish your context module

Learn More: Context Development


Hooks

Observability and control (logging, redaction, approval).

Reference Implementations: - hooks-logging - hooks-redaction

Getting Started:

  1. Review the Hook Contract
  2. Study reference hooks
  3. Implement hook handlers
  4. Test with event emission
  5. Publish your hook module

Learn More: Hook Development


Publishing Your Work

Module Naming

Follow the convention: amplifier-module-{type}-{name}

Examples: - amplifier-module-provider-gemini - amplifier-module-tool-database - amplifier-module-hook-metrics

Repository Structure

amplifier-module-tool-yourname/
├── amplifier_module_tool_yourname/
│   ├── __init__.py          # mount() function
│   └── ...
├── tests/
├── pyproject.toml
└── README.md

Entry Point

Register in pyproject.toml:

[project.entry-points."amplifier.modules"]
tool-yourname = "amplifier_module_tool_yourname:mount"

Documentation

Include in your README:

  • Purpose and use cases
  • Configuration options
  • Example usage
  • Contract compliance

Core Contributions

The kernel has a high bar for changes. Most functionality belongs in modules.

When to contribute to core:

  • Bug fixes in existing contracts
  • Performance improvements
  • Protocol clarifications
  • Documentation improvements

How to contribute:

  1. Open an issue describing the problem
  2. Discuss the solution approach
  3. Submit a PR with tests
  4. Reference the issue in your PR

Questions?

  • Slack: Join the community channel
  • GitHub Discussions: Ask questions, share ideas
  • Issues: Report bugs, request features

License

By contributing, you agree to the Contributor License Agreement.