Amp Code: Next Generation AI Coding – Beyang Liu

Building AMP: An Opinionated Frontier Agent [00:20]

• AMP is presented as an "opinionated frontier agent," embodying an ethos of embracing the "awe and absurdity" of the current era where AI generates a significant amount of code.
• The project aims to be an agent research lab operating "one year in the future," exploring the evolving landscape of AI in software development.
• The agent is invoked from the terminal and features a custom-built terminal UI framework that leverages modern terminal capabilities, focusing on displaying essential information without overwhelming the user.
• It streams diffs, shows CLI commands, and can connect to editors like Emacs, Neovim, and JetBrains IDEs to gather relevant diagnostics for tasks.

One of the balances we tried to strike in in this UI is we try to show the right amount of information to the user that conveys what the agent is doing without overwhelming you with, you know, every single token of explanation.

Editor Integration and Review Interface [02:22]

• AMP integrates into VS Code and its derivatives (Cursor, Windsurf), allowing users to write code primarily through an agent panel.
• A significant bottleneck identified in editor-based agent use is the time spent on code review, which can hinder productivity.
• To address this, AMP developed a "review reu interface" to streamline the process of understanding agent-generated code, ensuring quality and preventing sloppy output.

Um, I I actually spend very little time, you know, actually manually editing code now. And one of the bottlenecks we identified in the editor is I don't know about you, but I spend most of my time effectively doing code review now.

Core Architecture: Tools, Sub-Agents, and Model Choice [03:58]

• At its core, an agent is defined as a for loop with tool calls and a model, with levers for builders being the choice of model, tool descriptions, and iteration over tools.
• AMP made a deliberate, "opinionated" decision to focus on its core set of custom tools rather than heavily relying on MCP integrations, citing the need for tools specifically tuned to the agent's task and to avoid context confusion from too many generic tools.
• Context exhaustion is addressed through "sub-agents," which are analogous to subroutines, allowing tasks to utilize their own context windows and return only relevant results to the main agent, thereby conserving and extending the main agent's context.

And so one of the key lovers in building any agent is the set of tools. And these days you cannot talk about tools without talking about MCP.

Specialized Sub-Agents and Agent Modalities [07:32]

• AMP employs specialized sub-agents:
  • Finder: A codebase search agent using a small, quick model optimized for discovering relevant context.
  • Oracle: A sub-agent dedicated to complex reasoning, preserving the main agent's snappiness and tool flexibility by handling intricate problem-solving.
  • Librarian: Fetches context from external libraries and frameworks.
  • Kraken (Experimental): Focuses on writing code mods for large-scale refactors, rather than editing individual files.
• AMP contrasts with other agents by not using a model selector as a core UX component, arguing against the paradox of choice and the difficulty of optimizing for multiple models.

Anytime the main agent has trouble uh figuring out something and I'm like I don't want to spend like one to two hours going down this rabbit hole, I just like tag the oracles like invoke the oracle, think really hard.

Dual-Top-Level Agents and User Experience [09:48]

• AMP features two top-level agents:
  • Smart Agent: Has access to all sub-agents, capable of handling more complex instructions but is slower.
  • Rush Agent: Designed for in-the-loop tasks requiring quick, targeted edits, prioritizing speed.
• This dual-agent approach targets two user modalities: asynchronous task execution and review, or synchronous, in-the-loop editing.
• The smart agent was recently updated to leverage Gemini 3, with extensive testing to optimize its capabilities.

And so AMP's architecture is much more agent-oriented. We have two top level agents, a smart agent and a rush agent.

UI Layer: Editor vs. Terminal and Learning the Craft [11:21]

• AMP supports both editor and terminal interfaces, recognizing their different working modalities.
• In the editor, the focus shifts to the agent panel for driving edits, with the editor itself acting more as a reader and utilizing a custom diff viewer optimized for reviewing agentic output, including editable diffs and code navigation.
• The terminal UI leverages modern terminal features and rendering capabilities, with a custom TUI framework built by a core contributor to Ghosty. It also supports graceful degradation for compatibility with various terminals.
• AMP emphasizes learning the new craft of coding with AI, offering features like sharing "threads" (conversations with the agent) among teammates to share prompting techniques and problem-solving strategies.

So we actually built a custom diff viewer for the way that people are consuming agentic output. You can select any arbitrary commit range quickly view through the file level diffs.

Economic Accessibility and Community [14:14]

• Addressing the cost barrier of using AI agents, AMP has implemented a "mini ad network" that displays subtle ads for developer tools within its terminal and editor.
• This initiative sponsors inference for the "Rush Agent," making it more accessible for personal projects and broader experimentation.
• AMP positions itself as an "agentic research lab" that avoids hype and paid marketing, instead highlighting users like Mitchell Hashimoto (Ghosty contributor) and Hamill Hussein (AI evals authority) who find value in the tool.
• A "community of builders" has also been established, fostering experimentation and tapping into a sense of awe and wonder around agent development, with regular interviews and in-person events.

So, we actually shipped a mini ad network that delivers ads for other developer tools in in AMP in the terminal and in the editor. They're very subtle.