Amplifier: Notes from an experiment that’s starting to snowball

This is not a launch post for a new Microsoft release. It’s me explaining, prematurely and in public, what we’re building, why it matters, who it’s already helping, and why it’s absolutely not for everyone right now. I’ll share more about the value we’re getting out of it, how we’re using it, etc. in another post soon.

Why I’m doing this

I have more ideas than time. Every day I see possibilities I can’t reasonably explore such as new papers, patterns, workflows, architectural gambits I want to test. The constraint isn’t imagination; it’s the sequential, one-thing-at-a-time way we still work. Amplifier is my attempt to flip that constraint, an environment that lets AI work in parallel while I stay in the driver’s seat. The point is to multiply human capability, not replace it.

Out of the box, AI coding assistants are strong but context-blind. They don’t remember your patterns, don’t carry forward your prior decisions, and they need hand-holding on anything ambitious. Amplifier is the scaffolding around the model or AI agent tooling. It’s the knowledge, workflow, and automation that pile on, take control, and turn a helpful assistant into a force multiplier.

What Amplifier is (today)

Amplifier is a research-stage development environment that rides on top of an AI coding assistant (currently Claude Code and will soon be tool agnostic) and adds:

• Specialized “sub‑agents” for architecture, debugging, security, testing, API design, and more. The work goes to the right expert rather than a one-size-fits-all agent.
• Pre‑loaded context and philosophies so we don’t start from zero each session. The system carries forward patterns that have proven reliable and we use the system to continually learn from us and bake them for others.
• Parallel workspaces so I can try multiple approaches side‑by‑side and pick winners, instead of betting the farm on a single path. This is also great for accomplishing more in parallel in different workstreams simultaneously.
• A persistent knowledge base that mines our docs and notes into queryable structure, so the AI can recall what we’ve already learned.
• Automatic transcript capture and restoration so long sessions don’t lose their minds when compaction hits, we can rewind and continue with full context.
• Tooling that can self-improve the system from observations where users have guided the assistant, reducing the need for the user to do so in the future.

That’s the “force multiplier” effect: the model doesn’t change, the environment around it does.

The real secret: metacognitive recipes

Two years ago, we started chasing a simple idea: the most transferrable value isn’t any single tool, it’s the “metacognitive recipes” that expert users follow. If we can encode the how (decompose, plan, stage work, verify, recover from failure, how we make decisions, how we evaluate, how we think) we can teach tools to do what expert users do - and then anyone can benefit without first becoming an expert.

Practically, Amplifier bakes those recipes into workflows the AI follows by default: brainstorm → plan → implement → test; decompose big jobs into generative sub‑tools; prefer regenerate‑from‑spec over hand edits; capture learnings and feed them back. That’s how we get from “AI can kind of help” to “AI can run a whole play, unattended, until it needs my judgment.”

What it’s not (yet)

See our disclaimer.

• Not a Microsoft product or a formal release. This is a research demonstrator. It changes fast. You use it at your own risk.
• Not turnkey. Onboarding is rough. It assumes you’re comfortable with CLI, repos, environment setup, and reading docs.
• Not cheap. We’re pushing the models hard. We’ve publicly said we’re spending thousands of dollars per day on tokens right now. That’s the cost of running ahead to map the ground. When the patterns stabilize, we’ll make them cheaper for everyone.
• Not for everyone. If you want “point‑and‑click, guaranteed results,” this will frustrate you. If you like breaking down problems, composing systems, and iterating hard — you’ll feel at home.

Where the value is showing up

Parallel exploration becomes normal. With Amplifier, I can spin up alternatives in parallel: architecture A vs B, different data strategies, multiple scaffolds and compare quickly. A human might reasonably try one or two; I routinely try many more and keep what works.

Knowledge compounds. We extract useful concepts and relationships from content into a knowledge base the AI can query. The next task starts smarter because the system remembers what we learned on the last one.

The AI behaves more like a disciplined engineer. The recipes and agents push it toward plan‑first thinking, tests, quality gates, and recovery tactics; so, the default behavior is less chaotic and more dependable.

We build tools that build tools. A lot of Amplifier’s scenarios are literally tools that improve Amplifier - transcript processors, knowledge extractors, article illustrators, blog writers - each created from a “describe the thinking, then build it” flow. Over time, the environment gets smarter.

If you want to try it: how to approach it

Don’t start with “write code.” Start with describing how it should think and ask it to make that into a tool. Tell it the steps an expert would take, where to checkpoint, how to recover from failure, when to ask for judgment. Keep asks small and then ask it to use the tools together to do something more complex. When it fails (and it will), consider how to decompose the challenge and build the pieces that it can for itself in the larger space. That’s the way we build Amplifier.

You’ll also find practical guidance in our “way of working” docs and tips collected from real use, battle‑tested strategies, not theory.

What’s hard right now (on purpose)

• Claude dependency. Today the agentic loop is tied to Claude Code’s capabilities and CLI. We have built up a lot of learnings over the past few years, and the Claude Code “plumbing” is both convenient and powerful. This has allowed us to bring our research together into one space very quickly. However, it is also currently out of reach for people without Anthropic API access. We’re living with that tradeoff while we run fast at proving out the patterns.
• Onboarding & collaboration. The repo is evolving daily. Scenarios are helping, but curating workflows and taking PRs without breaking stability is still a work in progress.
• Cost & rate limits. Expect pay‑as‑you‑go and long sessions that hit ceilings. We watch cost live in our status line because it matters. Again: research mode.

What’s in the repo that you can study today

https://github.com/microsoft/amplifier

The scenarios/ folder has concrete examples with real value. They’re not toy demos; they’re tools we actually use, often created live to prove a pattern and then refined. Examples include a blog writer, web‑to‑markdown converter, transcript tooling, and an article illustrator that analyzes an article, generates prompts, calls multiple image APIs, and updates the markdown with images. Read the code, read the “how it was created,” and steal the recipes.

Where this is going next

The next version is modular and multi‑model. Think of a small, boring Linux-inspired “kernel” at the center; just a tiny coordinator with stable “syscalls” for creating sessions, mounting modules, emitting events, and managing context. Everything else — providers, tools, orchestrators, hooks, memory, agents — lives as swappable modules with stable contracts. If two teams might want different behavior, it’s user-space policy, not kernel. That’s the north star.

Concretely, that kernel direction means the additional value is coming soon:

• Multi‑provider by design. Claude today, something else tomorrow. The value is the knowledge, patterns, and automation — not any specific model.
• Unified, structured logs (think /proc) for audit and replay. If it’s important, it’s an event. If it’s not observable, it didn’t happen.
• Capability for approval‑based safety layered at the edges: least privilege, deny‑by‑default, policy in modules, mechanism in core.
• Swappable orchestrators. Want a sequential plan? A parallel planner? A chain‑of‑thought voter? Swap the orchestrator, not the core.

We’ll share more about this kernel‑inspired version soon.

Community + related work

We’re not alone. Others are exploring similar territory, and we’re trading notes. If you want a great field report from the trenches - and a complementary approach - read “Superpowers: How I’m using coding agents in October 2025.” It captures the same shift toward skills/recipes, structured workflows, and making agents better at building real systems.

Credits, intent, and a clear disclaimer

This work is 100% built on the shoulders of my team and collaborators around us. I’m the one writing this post, but this project is a collective push. The current dependence on Claude Code is convenience plumbing - a fast way to leverage years of exploration so we could start assembling what we already knew. We’re racing to distill patterns that make AI for everyone feel real: capture expert workflows once, encode them as recipes, and let the tools carry that expertise to others. The experiment is the point.

Final reminder: this is a research project, not a product. Expect rapid change, rough edges, and no guarantees. If you’re the kind of person who leans in, decomposes problems, builds tools and systems, and iterates without flinching — you might find it transformative even at this messy stage.

Appendix: quick pointers for the curious

• Vision & principles: why amplification matters; ruthless simplicity; modular “bricks” you can regenerate; human as architect, AI as builder. AMPLIFIER_VISION.md | MODULAR_DESIGN_PHILOSOPHY.md
• How the environment helps the model - agents, knowledge base, parallel work, transcript capture/restore. README.md
• Working patterns: describe‑don’t‑code; decomposition; regenerate across stable contracts; use transcripts to learn; meta‑learning over time. THIS_IS_THE_WAY.md
• Roadmap: multi‑Amplifier “modes,” agentic loop evolution, context sharing without exposing private data. ROADMAP.md
• Scenarios: real tools we use (blog writer, web‑to‑md, transcribe, article illustrator). Study them, adapt them, build your own. amplifier\scenarios

If you’re one of the folks already “getting it”: welcome. If you’re on the fence, that’s fine — come back when the kernel lands. Either way, thanks for paying attention while we work in the open.