The Invisible Team

Multi-agent orchestration you never see

The Frame

One clean reply hides a whole team

Amplifier hands you a single, clean conversation. The amplifier-bundle-orchestration package is the machinery that lets that one reply hide a whole team of specialist sub-sessions doing the work.

The whole point: coordination you never see is what makes one conversation feel simple. First, is the machinery even real?

Proof

The invisible engine is small — and verified

The entire orchestration engine is about 2,044 lines of Python across 5 files, covered by a passing suite of 77 tests.

Small enough to hold in your head. So what are its moving parts?

2,044

lines of Python across 5 files

5

source files (spawn, background, triggers, events, __init__)

77

passing tests (1,562 lines across 3 files)

Meet the Team

Four moving parts carry the whole team

Before the argument leans on them, meet the players the bundle exposes for multi-session coordination.

Everything downstream builds on the first of these — spawn_bundle.

spawn_bundle

Unified session spawning with inheritance controls

EventRouter

Cross-session pub/sub communication

Triggers

Timer, session-event, and manual trigger sources

BackgroundSessionManager

Long-running sessions that respond to triggers

Mechanism · How specialists are born

One primitive spawns the entire invisible team

spawn_bundle() is declared in-source as THE primitive for all session spawning in Amplifier — every agent, self-delegation, and worker builds on it.

One door in. But what walks through it, and how isolated is it?

# amplifier_orchestration/spawn.py:291-293
"""This is THE primitive for all session
spawning in Amplifier. All other spawning
patterns (agents, self-delegation, workers)
should use this function or build on it."""

Mechanism · Controlled isolation

Each specialist inherits only what you allow

spawn_bundle() gives fine-grained control over what a spawned specialist takes from the parent: which providers, tools, and hooks, and how much of the conversation it sees.

Specialists work apart without leaking into the main chat. But what stops them multiplying?

inherit_providers

default True

inherit_tools

default False

inherit_hooks

default False

context_depth

none | recent | all

context_scope

conversation | agents | full

The Tension

A team that fires freely could swamp you

Unchecked, the invisible team would overwhelm the simple surface. So worker pools are bounded: pool_size caps concurrency, and when active spawns hit the limit, extra triggers are silently skipped.

Bounded work stays quiet. But how does a specialist's result get back to you?

# amplifier_orchestration/background.py:436-439
if state.active_spawns >= config.pool_size:
    # skipping spawn

# pool_size default 1; worker-pool
# example in README uses pool_size=5

The Payoff

The result never barges into the chat

A background specialist's output never lands in the visible conversation. It flows back to the caller as an emitted session:end event carrying its output — or status "error" if it failed — then the session cleans up.

That single handoff is what keeps the work invisible and the conversation clean.

# spawn.py _run_background (:668-696)
event_router.emit("session:end", {
    session_id, bundle_name,
    status: "completed",
    output: response,
})
# on exception -> status "error"
# finally -> session.cleanup()

The Takeaway

The invisible team IS the product.

Orchestration you never see is exactly what makes one conversation feel simple — a pattern that reaches well beyond this one bundle.

Sources

Research Methodology

Repository: colombod/amplifier-bundle-orchestration (origin), fork/mirror of microsoft/amplifier-bundle-orchestration (upstream), branch main.

Feature status: version 0.1.0 — Development Status :: 3 - Alpha. 11 commits reachable from HEAD (13 across all refs including two off-main branches). Depends on amplifier-core and amplifier-foundation.

Commands run:

cat amplifier_orchestration/__init__.py — core primitives (spawn_bundle, EventRouter, Triggers, BackgroundSessionManager)
wc -l amplifier_orchestration/*.py — 2,044 lines across 5 files
uv run --with pytest --with pytest-asyncio pytest tests/ -q — 77 passed; grep -c 'def test_' tests/*.py; wc -l tests/*.py — 1,562 test lines
grep -n 'THE primitive' amplifier_orchestration/spawn.py; sed -n '291,293p' spawn.py — spawn_bundle is THE primitive
sed -n '259,286p' spawn.py — inheritance defaults; sed -n '668,696p' spawn.py — session:end emit + cleanup
grep -n 'pool_size' background.py; sed -n '436,439p' background.py — bounded pools, skip-over-limit
sed -n '46,64p' triggers.py; git log / git shortlog -sne --all / git rev-list --count HEAD — triggers, timeline, contributors

Primary contributors: Paul Payne (8 commits, on main), Salil Das (2 commits, on main), microsoft-github-operations[bot] (1, on main).

Gaps / caveats: No deployment, user-count, or latency numbers exist in the repo; none are claimed. "Invisible" is interpretive framing built on verified mechanics (background execution + session:end + no injection into the parent conversation); the repo does not use the word. FILE_CHANGE appears in the TriggerType enum but no FileChangeTrigger class is implemented/exported.