How Amplifier builds software.
Turn intent into working code through pluggable resolver backends.
A user writes a spec — what the software should do, defined as observable HTTP behavior. No implementation details.
A resolver instance explores the codebase, plans changes, implements them, tests in a live environment, and iterates until done.
The platform promotes results back to GitHub or Gitea as a PR. Working code, tested and ready for review.
The host handles lifecycle, routing, and validation. Resolvers own the semantics. The platform is a thin orchestration layer — not a monolithic AI.
A modular monolith: single Python process on a single host, with per-instance services running under Incus containers.
React SPA — A2UI rendering surface with optional viewport extensions for custom resolver visualization
FastAPI service — instance lifecycle, broker, resolver registry, auth, observability. ~24,000 lines of source.
One child process per phase, speaking JSONL over stdio via amplifier-resolver-sdk. Pluggable — discovered via entry points.
Sidecar containers: Gitea, GH-router, DTU spawn, Reality-Check spawn. New capabilities via CapabilityHandlerProtocol.
The instance-centric protocol that makes resolver plugins interchangeable.
Resolvers declare their input schemas via instantiation_schema. The host validates every POST /instances request before creation. Dynamic refinement supported via GET /resolvers/{name}/schema?params={...}.
Resolvers can request additional user input mid-run by writing structured request files with A2UI form schemas. The host exposes, validates, and routes responses back — a general, schema-driven mechanism.
Properties: name, version, description, supports_resume. Methods: instantiation_schema, workspace_spec, container_setup, message_types, run, on_input_response, on_message, stop.
Send typed messages to a running instance. Message types are validated against the resolver's message_types() for the current state. Unknown types return 422.
Per-instance event streams via GET /instances/{id}/events. Events logged to events.jsonl, state snapshots to state.json. Real-time observability.
Every instance follows a state machine from creation to completion — with pausing, input requests, and cancellation built in.
Instance record persisted. Container launches, worker initializes. Cache image cuts this from ~5 minutes to ~15 seconds.
Resolver actively working inside a container. May transition to awaiting_input or paused and back.
Terminal states. Success delivers a PR. Failure logs diagnostics. Cancellation is available from any non-terminal state.
The typical happy path: created → starting → running → completed. Each transition emits events to both the SSE stream and the Amplifier hook system.
Each resolver is a strategy plugin. The host provides infrastructure — resolvers own the intelligence.
Multi-stage AI pipeline — plan, implement, test, review. Ships as a submodule at amplifier-bundle-attractor.
Interactive resolver that pairs with a human developer in the loop for guided implementation.
Specialized resolver for architecture diagram generation and codebase visualization.
amplifier-resolve resolver add <spec> validates installation in an ephemeral worker container. amplifier-resolve init-resolver my-resolver scaffolds a new one.
Every resolver gets: workspace provisioning, Gitea sidecars, DTU environments, reality-check sessions, promotion to upstream repos, and container lifecycle management — for free.
GitSidecarManager provisions repos, clones, and sets up branches. PromotionService pushes results to upstream repos as PRs. Pure HTTP — no git binary needed.
The broker provisions per-instance sidecar services: ephemeral Gitea instances, Digital Twin Universe environments, and Reality-Check sessions — all running under Incus.
Validates resolver output against live services. Observable HTTP behavior — not source inspection. The platform tests what the code does, not how it's written.
Abstracted via ContainerProvider: Incus (primary) and Docker (fallback). Worker cache images cut startup from ~5 min to ~15 sec. Rebuild weekly.
User domain (/api/*): session cookies or bearer tokens via PAM/env/file cascade. Worker domain (/worker/*): instance-scoped tokens with container identity verification.
The full instance lifecycle as HTTP endpoints — designed for programmatic consumption by agents, scripts, and UIs.
Instance CRUD, input-requests, messages, events, state, workspace ops, broker services, sub-container management.
All 4xx/5xx responses use {code, detail, next_action} envelope. Idempotency-Key header with 24h dedup window.
amplifier-resolve doctor diagnoses issues. amplifier-resolve upgrade self-updates. install-service for systemd/launchd.
First commit April 29, latest May 20 — 100 commits in 22 days. 77 source files, 184 test files. A ~2.8:1 test-to-source ratio by line count. Built to be tested, not just to run.
Amplifier Resolve is the orchestration layer that turns every other Amplifier component into a code-generation pipeline.
amplifier-bundle-gitea provides ephemeral git. amplifier-foundation provides the core runtime. amplifier-bundle-attractor provides the AI pipeline. Resolve composes them into a working factory.
New coding approaches are new resolvers — not new platforms. Register with one command, validate in an ephemeral container, deploy immediately. The platform stays thin.
The host is a thin lifecycle/routing/validation layer. Resolvers own all resolution semantics. New capabilities are added as new broker handlers conforming to CapabilityHandlerProtocol.
One command to install. One command to start the server. One API call to generate code.
Repository: microsoft/amplifier-resolve — cloned and analyzed May 20, 2026.
9bf3b55 (Apr 29) to d4eb669 (May 20)src/amplifier_resolve/tests/; ~3,400 test cases (per README)Sources consulted:
README.md — API surface, quick start, environment variables, architecture tabledesign/ARCHITECTURE.md — four-layer architecture, two-domain auth, router topologydocs/INSTANCE_LIFECYCLE.md — 8-state machine, transitions, state diagramdocs/AUTHORING_GUIDE.md — instance spec conventions, observable behavior requirementamplifier-resolve.yaml, amplifier-bundle-attractor.yaml, amplifier-reality-check-runner.yamlcore/resolve_orchestrator.py, core/events.py, broker/, containers/, workspace/Commands used: git log --oneline | wc -l, git shortlog -sn --all, find . -name "*.py" | xargs wc -l, wc -l on key modules.
No metrics were fabricated. All numbers come from git history and file system analysis at the commit referenced above.