Amplifier in Action

A real Amplifier session, running in your browser

The setup

Easy to start, hard to finish

A week of AI exploration is easy to begin. But the work ends up stranded — scattered across old sessions and separate codebases — and gluing it into something actually shipped is the real problem.

So what would it take to prove the finished-and-shipped part is real?

Proof, up front

This deck isn't a mockup — it ships a real Amplifier

The single HTML file embeds a real amplifier-core 1.0.0 wheel plus a browser runtime, base64-encoded inside the page. It was committed and published to GitHub Pages on Jan 27, 2026.

Real and shipped — so why is doing this normally so hard?

80,172

decoded bytes of the embedded amplifier-core wheel

21,253

decoded bytes of the embedded browser-runtime module

Jan 27

2026 — published to GitHub Pages by Brian Krabach

1.0.0

amplifier_core wheel version in the installer

The catch

The pieces live in past conversations and other repos

To reassemble a week of exploration, the parts you need are scattered: buried in old sessions and split across separate codebases. Normally you'd hand-wire them back together yourself — the most manual glue work there is.

Amplifier removes that glue with two built-in mechanisms.

Old sessions. The conversation you need happened days ago and is out of reach.
Separate codebases. The relevant work sits in a different repo or bundle.
Manual glue. Stitching it all into finished output is the hardest part.

Mechanism — memory

Cross-session memory finds that old conversation

Amplifier's session-analyst agent searches your past sessions by ID, project, date, or topic. Ask it “find the conversation where I worked on authentication” and nothing stays stranded.

Recovered pieces still have to become finished work — that's the second mechanism.

# session-analyst agent, in its own words
User: "Find the conversation where I
       worked on authentication"

→ "I'll use the session-analyst agent
   to search through your Amplifier
   sessions."

# Searches sessions by:
   ID · project · date · topic

Mechanism — coordination

One prompt fans out into real work across repos

Agent coordination does the assembly. The storyteller agent delegates research to a dedicated story-researcher agent that mines git repos, sessions, and bundles — so a single plain-language prompt turns into finished output.

These mechanisms are only shippable because of one browser-native breakthrough.

1You give storyteller one plain-language prompt.
2storyteller.md (line 15) delegates: research is MANDATORY.
3story-researcher mines git repos, sessions, and bundles.
4The recovered pieces come back as finished output.

The turn

A browser-native breakthrough makes the session live

The same breakthrough that makes those mechanisms shippable — running Amplifier entirely in the browser via WebGPU and Pyodide — is what lets this deck carry a live session inside it. Open a web page, get a complete AI dev environment with local LLM inference.

Which turns the argument into something you can hold.

WebAmp

runs Amplifier in the browser via WebGPU + Pyodide

Jan 20–21

2026 — breakthrough attested in a weekly memo

13+

pull requests merged that week by bkrabach

Proof you can hold

Press run — a real session drives a local model

Inside this page, a genuine session.execute() loop runs over a local WebLLM via Pyodide + WebGPU — not a simulation. The workflow the deck describes, shipped as a live artifact that demonstrates itself.

That's scattered-to-shipped, made tangible.

# real wiring inside the single HTML file
micropip.install('emfs:/tmp/
  amplifier_core-1.0.0-py3-none-any.whl')

CreateMLCEngine(selectedModelId, ...)

response = await session.execute(...)

# 6 wiring hits: session.execute x3,
#   CreateMLCEngine x2, micropip.install x1

The throughline

Scattered explorations become shipped work at prompt speed

When memory and coordination are built in, a week of scattered explorations turns into shipped work at the speed of a prompt — and this deck proves it by being one.

With honest receipts: some figures here are measured; the workflow scoreboard is illustrative.

Active / Shipped

Measured: the embedded wheel, byte sizes, ship date, and real session.execute wiring — all re-derived from the file and git history.
Illustrative: the “7 prompts / 2 sessions / 3 codebases / 0 lines” scoreboard is the story's narrative receipts, not audited metrics.

Sources

Sources & Research Methodology

Data as of: 2026-07-14 (deck regenerated spine-first by Sam Schillace, commit 3bcf9c1).

Feature status: Active / Shipped.

Research performed:

Embedded-artifact sizing: python3 re over docs/amplifier-in-action.html for id=amplifier-wheel-b64 / amplifier-browser-py, base64-decoded → 80,172 and 21,253 bytes.
Real-session wiring: grep -c "session.execute\|CreateMLCEngine\|micropip.install('emfs" → 6 hits.
Ship history: git log --follow -- docs/amplifier-in-action.html → 712deb0 & 9453117 (2026-01-27, Brian Krabach).
Cross-session memory: read_file agents/session-analyst.md (microsoft/amplifier-foundation).
Agent coordination: read agents/storyteller.md (line 15) and agents/story-researcher.md.
WebAmp context: grep -n -i 'January 20-21\|WebAmp\|webgpu\|pyodide\|13+ pull' Inactive/amplifier-weekly-accomplishments.md.

Gaps / illustrative: The workflow scoreboard (“7 prompts, 2 past sessions, 3 codebases, 0 lines of manual code”) and the per-day Jan 19/21/23 session dates could not be traced to any session transcript — treated as narrative receipts, not measured facts. The embedded prompt's “~2,600 lines” figure is unsupported (measured 8,134 total / 6,677 non-test Python lines) and is not repeated here.

Primary contributors: Brian Krabach (bkrabach) — authored/published the browser demos and the WebAmp runtime; Sam Schillace (ramparte) — repo owner, regenerated the current narrative.