No Server, No Keys

Amplifier agents running entirely in the browser

The Tether

Amplifier is powerful — but it's tethered to a host, keys, and a cloud bill

Amplifier is real Python (amplifier-core) that gives you working AI agents. But it normally needs a host to run on, LLM API keys, and cloud inference spend — no privacy, nothing offline.

Two new composable bundles cut the cord and run it in the browser.

Proof — Not a Mock

amplifier-bundle-webllm ships a genuine amplifier-core Provider

WebLLMProvider is 154 lines of Python implementing the amplifier_core.protocols.Provider interface. Its docstring: "Provider that runs LLM inference locally via WebLLM/WebGPU." Real inference on WebGPU, not a shim.

So the agent brain is real — but where does it run?

154
lines of Python in WebLLMProvider
webllm
provider name (class WebLLMProvider)
WebGPU
where inference actually runs
The Catch

Amplifier's engine is Python — and browsers don't run Python

A real amplifier-core Provider is only half the story. By default, none of it could work client-side: the browser has no Python interpreter to run the engine.

So the first thing to solve is getting Python itself into the browser.

The Runtime Half

amplifier-bundle-webruntime runs the actual amplifier-core inside the browser

It uses Pyodide and a two-sided JS/Python bridge to run the real Python amplifier-core client-side. Originally named amplifier-bundle-browser, then renamed to webruntime.

Python now runs in the browser — next, make inference keyless too.

The Inference Half

The webllm provider defaults to a small quantized model on your own GPU

Its default model is Phi-3.5-mini-instruct-q4f16_1-MLC — small enough to run in-browser. Inference happens locally on the user's own GPU: no API key, no cloud call.

Runtime plus provider — now prove the two halves compose.

# provider.py default self.default_model = config.get( 'default_model', 'Phi-3.5-mini-instruct-q4f16_1-MLC' ) # q4f16 quantization — local WebGPU inference
The Proof-of-Concept

To prove the halves compose, Brian Krabach built amplifier-polyglot-demo

amplifier-polyglot-demo is a single self-contained HTML file: a four-language AI agent that exposes Rust, TypeScript, Python, and Go as agent tools through a JS bridge.

One file, four languages — and it runs with no server.

Serverless, Keyless, Proven

One HTML file runs a Qwen3-4B agent client-side — and passes 49 end-to-end tests

The demo settled on Qwen3-4B with JSON Schema constrained decoding for reliable tool calling, running entirely client-side with no server, verified by 49 end-to-end tests.

Serverless, keyless, offline Amplifier — proven, not promised.

1
self-contained HTML file, no server
Qwen3-4B
model running client-side
49
end-to-end tests passing
What You Keep

Two composable, MIT-licensed bundles make "Amplifier in the browser" a shippable pattern

Both bundles are public and MIT-licensed under microsoft/*. Together the runtime and provider give you a reusable pattern: bring your own GPU, keep your data, drop the bill.

Serverless, keyless, offline, private — by construction.

Sources

Research Methodology

Data as of: July 2026  |  Feature status: Shipping/public (both bundles MIT-licensed under microsoft/*)

Every claim independently re-derived from live command output:

Gaps: No dollar/latency benchmark exists in these repos; cost/offline framing is narrative rationale, while code confirms local WebGPU inference and no-server operation. Full supported-model list not verified (Phi-3.5-mini default confirmed in provider.py; Qwen3-4B confirmed in the demo).

Primary contributor: Brian Krabach (bkrabach) — creator/primary author of both bundles and the polyglot demo (webllm 16/21 commits, webruntime 34/39). OSS governance PRs by Salil Das (sadlilas).

More Amplifier Stories