Stories

The graph is the workflow — a field report on convergence pipelines

How we stopped writing recipes with a convergence tool: corrective back-edges, evidence gates, a pipeline pointed at its own repository, and the scars that produced each rule.

amplifier-work-tracker — a shared work queue for coding agents

A shared work queue your coding-agent sessions pull from. One item, one agent. Nothing done twice, nothing dropped.

alexa-tester — Amplifier can now build and test Alexa skills

android-tester — agents that actually see the emulator screen

ios-tester — the iOS counterpart to android-tester

The Product Development Council — Announcement

amplifier-simulated-user-research — Announcement

/goal — autonomous continuation in Amplifier

Set a completion condition. Amplifier keeps taking turns until it's actually met.

Skills Index, Now Riding the Cache — Amplifier

Prefix placement for skills visibility — full, always-current skill discovery at a fraction of the cost.

MCP Tool Module — Three Silent Failures, Fixed

The MCP client now works on the SDK you actually have installed, speaks the protocol you think it does, and stops losing tools mid-list.

/monitor — Amplifier Skill

A turn that doesn't end until the thing you're watching is actually done.

You're Not the Bottleneck

Automatic context compaction in Amplifier

The Foundry and the Machine

89K lines the model never wrote

Slim It Without Breaking It

Testing a lean Amplifier config in a disposable twin

A DTU Inside a DTU

how Reality-Check learned to test itself

The Convergence Gate

How Reality Check turns intent into evidence

The Wiki That Compounds

Karpathy's pattern, dormant-by-default in Amplifier

The Ghost You Can Review

A personality, extracted from real interactions

One Conversation, Sixteen Services

The MCP bridge behind Amplifier's Agency bundle

One Component, One Process

amplifier-ipc breaks the monolith apart

A Plugin, Not a Platform

A thin host, pluggable resolvers

The Choke Point

Governing AI agents at the API call

The 85% Wall — How BookFoundry writes the last 15%

How BookFoundry writes the last 15%

Agents In Your Slack

An AI-native platform bridged to Slack

The System That Builds Itself

Amplifier's adversarial bundle factory

Your Sessions, Illustrated

Turn a JSONL log into a comic book

The Agent Takes the Wheel

Bounded, dual-world desktop control for agents

The Dev Machine Grew a Brain

A self-healing control room for an autonomous fleet

Less Context, More Memory

dev-memory V2 cut startup context 93%

Director Deck — Your Slides, Animated

A text prompt into a cinematic deck

The Poster Comes Alive

One HTML file that makes .dot graphs navigable

Vibes With a Number

Calibrated LLM judges for agent quality

Prove It's Done

Flywheel's evidence-driven methodology for AI agents

One Agent, Every Channel

Your AI, everywhere you already message

The Agent That Remembers

A five-tier persistent memory for Amplifier

Sessions Come to You

Federating a fleet of tmux into one browser tab

One Search, Both Halves

Fusing three indexes to search any codebase

The Safe Path Only

Natural-language M365 without lowering IT's guard

Not Me

Making a writing voice measurable

Rigor as Enforced Habits

A bundle that won't let you overclaim

Nobody Drew The Blueprint

How an AI operating system built itself

The Session Cockpit

Co-pilot a running AI agent

Teaching AI Taste

Anti-slop frontend design, made grep-testable

What Did We Actually Ship?

Accountability from evidence, not reports

Team & Methodology

How the team works, measures outcomes, and builds a culture of accountability. Process stories, methodology frameworks, and team practices.

The App Is YAML

Use it, then talk it into becoming yours

Zero Translation Loss

measuring how much intent survives to ship

Born Ready — on_session_ready()

one lifecycle hook that ends mount-order guessing

Reality Check Grows Up

A QA oracle for TUI, CLI, and web

Write a Program, Not a Prompt

Collapsing N tool round-trips into one

Launch Once, Update In Place

A fast iteration loop for isolated environments

Evidence, Not Echoes

Real-enough worlds on demand from one YAML profile

Reality Check — An Amplifier Story

Proving "done" means done

Where Did the Time Go?

Turning hostile event logs into one timing report

Search Before You Build — Amplifier Stories

Team knowledge, findable at session start

Context That Never Forgets

Graceful degradation for long AI sessions

Caveman Mode

An ultra-terse overlay that keeps the substance

The Missing /config

Editing a live Amplifier session, no restart

Amplifier Builds Amplifier

The GitHub Copilot provider story

Every Session Starts Sharp

Context rot as a systems problem, not a prompt problem

Signal Over Noise

Encoding how a person communicates

Faking Slack

Mocked external services for agent-driven testing

It Works When Deployed

A disposable world to prove your app is real

Prompt to Component Tree

Turning AI UI generation into a learnable function

The Self-Auditing Codebase

Architecture as a bug specification

Skills That Outlive the Session

/skillify and /adapt-skill for Amplifier

The Whole Bundle, One Diagram

Token cost the source never shows

It's Waiting For You

A local, read-only dashboard for every Amplifier recipe

One Command Back In

tmux-scoped Amplifier sessions, 1833 lines

Every Recipe, Now Legible — Amplifier

auto-generated flowcharts for dense recipe YAML

Fearless Git for Agents

Disposable Gitea servers for AI experimentation

Digital Twin Universe

Where AI-built code faces reality

Thinking Partner, Not Typist

AI upstream of code shipped amplifier-chat

Two Lines, Two Bugs

What the primary source actually shows

The Skill Grows Up

A Markdown file that runs itself

Prove It, Don't Assume It

Adversarial rigor for AI research

READMEs AI Can Explain

A problem-first README skill for Amplifier agents

Native iOS, One Day

A full-stack app shipped between lunch and bedtime

Delete the Wrong Door

How removing a choice fixed a broken agent

14 Lines to Infinity

Composition, not configuration

AI as a Document

A whole agent in one HTML file

The Ghost in the Network

Chasing an HTTPS bug that wasn't one

Amplifier, In Your Browser

A conversational front end for Amplifier sessions

Scores You Can Trust

How a rebuilt harness earns its numbers

The Sidecar's Missing Metadata

When freezing Python breaks a plugin loader

The Revert That Won

one week toward production for amplifier-app-api

The Protocol Boundary

One line that makes Amplifier apps clean

Architecture & Philosophy

The design principles, technical architecture, and philosophical foundations that make Amplifier fundamentally different. For engineers who want to understand not just what, but why.

Specs as Source Code

Prose plus an AI swarm, compiled into working software

The Builder's New Edge

Coaching how you build, not just what

Monolith to Platform

How Canvas became @canvas/shell

Composition All the Way Down

How 11 lines of YAML become a running agent

The Week It Watched Itself

One engineer, one week, a graph that observes Amplifier

You Write Specs, Not Code

A disposable dev machine builds the rest

The Diagram Is the Byproduct

DOT graphs as analysis infrastructure

From Bland to Brilliant

Two features, polished before lunch

The Model Drop That Landed

GPT-5.4 across Amplifier, zero user config

When Green Tests Lie

Building real orchestration under process discipline

Skills That Build Skills

Why durable skills carry their own templates

Override One Line

Layered, shareable model config

The Rails on Modes

Making Amplifier's pipeline structural, not advisory

One Model Can't Review Itself

Provider diversity turns blind spots into caught bugs

Confidently Wrong

Multi-agent investigation that ships proof

Catch Broken Recipes Early

A 7-phase validator that gates merges

Stable Names, Shifting Models

One matrix routes every agent

Building the Storyteller

Making narrative judgment auditable

The Tool That Built Itself

One evening, one non-coder, a self-correcting PR reviewer

How Do You Know?

Five words that beat three blind rounds

One Way To Spawn

Unifying session spawning behind spawn_bundle()

Teaching AI to Follow Through

When clearer instructions beat code

Plain Text Response

why an agent pipeline passes files, not prompts

Drawing the Ownership Line

Superpowers v2: own integration, borrow methodology

Teaching AI Taste

185 lines of markdown, zero code

Give the AI Eyes

Visual testing for terminal UIs

The Garden

Plant a seed, harvest a reviewed PR

The Invisible Team

Multi-agent orchestration you never see

Nobody In The Room

Amplifier talks to itself to test a chat app

The Still Center

How a tiny kernel lets everything else move

The Story of All Stories | Amplifier

One small kernel, one large ecosystem

Teaching AI to See | The ui-vision Story

Giving any agent eyes

Clipchamp to CLI

One sentence beat a cloud upload

Say It Once — Persistent Memory for AI Agents

Persistent memory for AI agents

Name Every Tab

Self-describing terminal titles, zero LLM overhead

Requirements, One Question

A guided Q&A that ships a stakeholder-ready doc

Give the AI Eyes

Closing the visual loop for AI coding sessions

Untangled - An Amplifier Story

One fleet, one crash, one source of truth

Grounding the Long Session

what the receipts actually support

Agents That Answer Each Other

Peer-to-peer A2A for Amplifier, with a human in control

Right-Sizing the Swarm

Per-agent model routing in Amplifier

Docs That Hash Themselves

Repo docs generated from source, fingerprinted for drift

Agents That Check Their Work

LSP navigation plus a per-edit quality loop

The Rust Development Home

LSP, quality, and expert agents in one bundle

One Call, Full Container

14-step provisioning collapsed into one create call

Grep Can't Read Code

Giving AI agents IDE-grade code intelligence

A Kernel for Agents

Amplifier's Linux-style mechanism/policy split

One Tool: Delegate

A voice model that only orchestrates

Every Session Was An Island

Cross-session memory, synthesized from local data

Deleting a Second Platform

How Kepler became a surface, not a fork

Reporting at Near-Zero Effort

Support, status, and stories from the session itself

AI That Checks AI

Cross-validation from composable providers

Past the 10,000 Wall

A pre-WWI corpus pipeline designed around the throttle

43 Million Fixes, 21 Minutes

A Rust + PyO3 OCR cleanup pipeline

Self-Awareness From the Outside In

A self-improving orchestrator built from standard parts

The 50% Rule

Why AI validators must verify against real code

Build, Then Verify

How the Canvas Artifact Viewer earned trust

Making Agents Visible

A real interface for terminal agent work

The Marathon Session

How one agent shipped a terminal UI

Fail Closed — Azure ZAP

A safety-gated pipeline for Azure deployment

The Blueprint Before The Build

Nexus Phase 0: planning that earned its keep

The Tool Tests Itself

A regression suite for the Amplifier CLI

Forge — One terminal skill, every harness

One terminal skill, every harness

Fast Without the Mess

One developer, one clean full-stack app, built with Amplifier

Pixels Into Structure

Vision pipeline that lets agents read a UI

The Kernel in the IDE

Amplifier's full agent, native in VS Code

Eyes and Hands

Giving AI agents a real browser

Chasing the Ghost

How two engineers debugged a stale-state error together

Not Every Other Dashboard

Design Intelligence for AI-built interfaces

Does Validation Actually Help?

Two design critics watch the pipeline

Which Agent Actually Won?

Blind head-to-head benchmarking in eval-recipes

Expressed Ownership

Reattaching what you express to who owns it

Agents That Clock In

Amplifier as co-developer through the M365 auth gauntlet

Green Checkmarks Lied

Two-layer defense for AI PR review

Block Everything But Recipes

A runtime overlay that stops improvisation

A Crowd Over Your Shoulder

Background AI reviewers that watch as you code

Ship It, Walk Away

One command for the whole PR lifecycle

Giving Amplifier Eyes

How an AI built its own terminal vision

The Bot Ships The Site

Session → Story → Site, on autopilot

Three Branches, One Recipe

How three features became one step

Declared vs. Proven

Proving parallel execution from timestamps

Don't Trust, Restore

Wrapping the LLM in deterministic code

The Week Recipes Grew Up

Hardening the Amplifier recipe engine for production

Compose a Team

delegation as an orchestration primitive

Amplifier in Action

A real Amplifier session, running in your browser

Swarm — Parallel Agent Tasks That Survive Crashes

Parallel agent tasks that survive crashes

The Poor-Man's BBS

Five agents debate their way to a UI kit

No Server, No Keys

Amplifier agents running entirely in the browser

Two Boxes, One Brain

A real distributed AI cluster on DGX Spark

The Server That Runs Amplifier | Amplifier Story

10K lines of always-on AI runtime

Structure Beats Tooling

Same stack, opposite outcomes

From .gitignore to M365

A verifiable M365 integration in 9 days

The Judge Isn't the Builder

Independent validation for Amplifier shadow environments

The Stories Bundle

A team of agents that ships content

Amplifier SDK - Building Just Got Easier

Building on Amplifier just got a whole lot easier. TypeScript & Python.

When Hand-Copied Content Drifts

Source-driven content on withamplifier.com

Modes That Can't Betray You

Runtime behavioral overlays for Amplifier agents

Attention Firewall

A rule pipeline for your notifications

Strip It To Foundation

The Thin Bundle discipline, caught in the act

Composable by Design

Capabilities that layer, share, and delegate

The Right Slice

Context inheritance for delegated agents

Cortex · One always-on brain, built on Amplifier

One always-on brain, built on Amplifier

The $5 Agent Turn

Three composable levers that cut the token bill

One Query From DROP TABLE

Read-only SQL access for AI agents

Slow Down to Ship

Front-loading judgment before AI writes code

Show, Not Just Tell — Diagrams Tool

Agent diagrams with zero local renderers

67 Repos, One Command

Microsoft OSS compliance on autopilot

Three Commands to Amplifier

Install, init, run — on a thin kernel

Eyes on the Pipeline

A GitHub Actions tool for AI agents

Least Privilege by Default

Tools that activate only when an agent needs them

Vibe Code, Safely

Governance as the moat for enterprise AI coding

When You're The Blocker

A push notification hook for Amplifier, built by Amplifier

Recipes Don't Lose Work

Multi-agent workflows as durable YAML

Branch Your Thinking

Git-like forking for AI sessions

Shadow Environments

Test your exact working tree before you push

Discipline You Can't Rationalize

Blocking the write tool, not the prompt

Code Is No Longer Precious

Vibecoding practices for AI-assisted development

The Semantic OS

An operating system nobody planned

One Concept, One Mechanism

Amplifier's ultra-thin bundle layer