One Component, One Process

amplifier-ipc breaks the monolith apart

payneio/amplifier-ipc

The Rearchitecture

Amplifier v1 ran everything in one Python process — amplifier-ipc gives every component its own subprocess

v1 packed the orchestrator, tools, hooks, providers and context manager into a single process. amplifier-ipc rebuilds Amplifier so each of those runs as its own subprocess behind JSON-RPC 2.0 over stdio.

And this isn't a proposal — it already shipped.

orchestrator
tools
hooks
providers
context manager

each now its own subprocess

The Proof

One author rebuilt Amplifier and deleted the entire Rust kernel

In ~10 days and 407 commits, Paul Payne (394 of 407 commits) drove the rewrite. The repo's own cloc comparison: ~55,448 Python+Rust lines down to 15,742 Python — the Rust engine eliminated entirely.

So why break the monolith apart at all?

407

commits in ~10 days (Mar 20–30 2026)

55,448

old Python+Rust lines (repo cloc)

15,742

new Python lines (repo cloc)

0

Rust — engine eliminated entirely

The Cost of One Process

One process meant one fate — a buggy tool could take down the whole session

In the old system every module ran in the same Python process. A buggy tool could corrupt shared state, leak memory, or crash the entire session. A shared virtualenv forced dependency hell, and the whole thing was Python-only.

The fix: stop sharing the process.

Corrupt shared state
Leak memory across modules
Crash the entire session
Shared virtualenv → dependency conflicts

How Isolation Works

Every component now runs as its own subprocess with its own process group

Each service is spawned with start_new_session=True for process-group isolation, talking to a central host over JSON-RPC 2.0 via stdio. A crashing tool service no longer takes down the session — the host detects the exit and the rest continues.

Isolation is one payoff. Dependency freedom is the next.

# lifecycle.py:56
subprocess.Popen(
    ...,
    start_new_session=True,
)
# JSON-RPC 2.0 over stdio
{"jsonrpc": "2.0", ...}

Dependency Freedom

Each service gets its own uv virtualenv — conflicting pins coexist

Every service has its own uv-managed virtual environment with dependencies declared in its own pyproject.toml. Service A can use pydantic==2.0 while Service B uses pydantic==1.10. No conflicts, no workarounds.

And the seam that enables this is astonishingly small.

Service A — venv pins pydantic==2.0
Service B — venv pins pydantic==1.10
Independent pyproject.toml per service
No shared-venv dependency hell

The Hinge

The framing layer is ~40 lines — any stdin/stdout process can be a service

The JSON-RPC newline-delimited framing layer measures 39 lines (the design doc rounds to "40 lines"). Any language that can read stdin and write stdout can be a service — polyglot comes essentially free. (A Python SDK is the only one shipped today.)

That tiny seam is the thing designed to scale.

~40

lines in protocol/framing.py (39 measured)

stdin
stdout

the only contract a service must speak

The Payoff

The IPC seam is designed to become a container seam: one behavior = one container

The repo's microservices design doc turns today's stdio JSON-RPC boundary into tomorrow's boundary: a Dapr-native framework where each behavior runs as an independent container over HTTP/gRPC and pub/sub, with Dapr sidecars for invocation and state.

Design-only for now — no Dockerfiles or Dapr components in the source yet.

Today — stdio JSON-RPC seam between subprocesses
Design — one behavior = one container
Transport — HTTP/gRPC + pub/sub via Dapr sidecars
Design doc only, not yet implemented

The Takeaway

Draw the boundary once, make it the seam that scales — honestly

The stdio JSON-RPC seam of today is engineered to become the HTTP/gRPC container seam of tomorrow. But the repo names its own catch: the foundation service still co-locates orchestrator+tools+hooks+context in-process to dodge deadlock, spawning costs ~200ms per turn, and the host is still a single 1248-line broker.

The payoff is earned, not oversold.

_OrchestratorLocalClient still a co-located monolith
~200ms per-turn spawn overhead (doc-stated)
Single-host broker mediates every message
Python-only in practice today

Sources

Research Methodology

Repository: payneio/amplifier-ipc @ d82d2d8 (branch main, HEAD 2026-03-30), remote git@github.com:payneio/amplifier-ipc.git

Data as of: 2026-03-30 · Feature status: Active (Dapr/container direction is design-doc only, not implemented)

Commands run:

Timeline: git log --reverse --format='%ci %h %s' | head -1; git log --oneline | wc -l (first 6205449 2026-03-20; 407 commits)
Contributors: git shortlog -sne --all (Paul Payne 394, Amplifier Implementer 13)
Line counts: wc -l src/amplifier_ipc/protocol/framing.py (39); wc -l src/amplifier_ipc/host/host.py (1295)
Isolation: grep -rn 'start_new_session' src/ (lifecycle.py:56)
Protocol: grep -rn 'jsonrpc' src/amplifier_ipc/protocol/client.py
Docs read: README.md, docs/architectural-comparison.md, docs/design/amplifier-ipc-microservices-design.md, docs/design/amplifier-ipc.md

Gaps: Old-repo LOC (33,753 Python + 21,695 Rust → 15,742 Python) and ~200ms per-turn overhead are repo-documented (cloc / design doc), not independently re-measured or benchmarked by the verifier. host.py measures 1295 lines today vs the doc's cited 1248 (minor drift). No Dockerfiles or Dapr components exist in source yet.

Primary contributor: Paul Payne — 394 of 407 commits (~97%).