AMP: An Opinionated Frontier Agent - Detailed Summary
Key Concepts:
- AMP: An opinionated coding agent developed by a research lab focused on future agentic workflows.
- Sub-agents: Specialized agents used to offload specific tasks and conserve context window space. (Finder, Oracle, Librarian, Kraken)
- MCP (Model Call Protocol): A protocol for providing context to agents, which AMP intentionally minimizes reliance on.
- Context Confusion: The issue of agents becoming overwhelmed by too many irrelevant tools in the context window.
- Doom Loop Mode: A failure mode where an agent doesn’t gather enough initial context and repeatedly retries the same unsuccessful action.
- Smart Agent vs. Rush Agent: Two top-level agents within AMP, optimized for complex tasks and rapid iteration respectively.
- Terminal UI & Editor Experience: AMP offers both a dedicated terminal interface and an editor integration (VS Code and derivatives).
- Agentic Research Lab: The ethos of the development team – focusing on exploring the future of agent-assisted coding.
I. Introduction & The Ethos of AMP
The presentation introduces AMP, described not just as a coding agent, but as a product of an “agentic research lab” aiming to explore the rapidly evolving landscape of AI-assisted development. The team embraces the “weird and magical” feeling of agents writing code, positioning themselves as forward-thinkers – “living one year in the future” to understand how these tools will reshape development workflows. They emphasize a focus on “awe and absurdity” in the face of this change. The team is identifiable at conferences by their distinctive booth featuring a “weird pied piper dude on the floating golden fish.”
II. What is AMP? – Core Functionality & UI
AMP is a coding agent invoked from the terminal, offering a complete terminal UI framework built from scratch. The UI is designed to balance information display – showing the agent’s actions (CLI commands, diffs) without overwhelming the user with every token generated. Crucially, AMP integrates with popular editors (Emacs, Neovim, JetBrains) to collect diagnostics and relevant context. A live demo showcases AMP adding a help button to its own interface, demonstrating its ability to identify relevant context and iterate towards a solution.
An editor experience is also available, integrating into VS Code and its derivatives (Cursor, Windsurf, Anti-Gravity). The presenter notes that they spend very little time manually editing code, instead relying on the agent panel. A key bottleneck identified is code review – the sheer volume of agent output requiring careful scrutiny. To address this, AMP includes a dedicated “review UI” designed to streamline the process and prevent the shipping of “sloppy or spaghetti” code.
III. AMP’s Differentiators: An Opinionated Approach
The core argument is that AMP isn’t simply another coding agent; it’s built on a fundamentally different, “opinionated, and weird” architecture. The presenter avoids direct comparisons, encouraging users to evaluate AMP based on their own experiences. The presentation then details the architectural decisions that set AMP apart.
IV. Building Blocks: Agents, Tools, and the MCP Debate
The presentation breaks down an agent into its core components: a for loop, tool calls, and a model. This highlights the limited number of “levers” available to agent builders – model choice, tool descriptions, and iteration logic.
A key decision point was the level of investment in MCP (Model Call Protocol). While acknowledging MCP’s potential, AMP’s team opted to prioritize a custom toolset. The rationale is twofold:
- Feedback Loops: Effective agents require identifying and closing feedback loops, which necessitates a refined, task-specific toolset that MCP servers, lacking task awareness, cannot provide.
- Context Confusion: Adding numerous tools (via MCP) increases context window usage and can confuse the agent if those tools aren’t relevant to the current task.
The presentation also addresses the issue of context exhaustion – agents spending too much time gathering context (e.g., through grep) and leaving insufficient space for editing. This leads to either premature termination or a “doom loop” of repeated, unsuccessful attempts.
V. Sub-agents: A Core Architectural Component
The solution to context exhaustion is sub-agents, analogous to subroutine calls in traditional programming. Sub-agents isolate tasks into separate context windows, returning only relevant results to the main agent. AMP’s approach to sub-agents is unique: rather than generic sub-agents, it utilizes a small number of highly specialized core sub-agents:
- Finder: A codebase search sub-agent optimized for quickly discovering relevant context. It uses a relatively small and quick model.
- Oracle: A reasoning sub-agent, designed to handle complex debugging and planning. The presenter describes it as “magical,” often resolving tricky problems after a period of deep thought.
- Librarian: A sub-agent for fetching context from external libraries and frameworks.
- Kraken: A new, experimental sub-agent focused on large-scale code refactoring through code mods.
VI. Model Selection & the Smart/Rush Agent Paradigm
AMP rejects the common practice of offering a wide range of model choices, citing the “paradox of choice” and the difficulty of optimizing models when they are lightly customized within a single agent harness. Instead, AMP employs two top-level agents:
- Smart Agent: Accesses all sub-agents, capable of handling complex tasks, but slower.
- Rush Agent: Designed for rapid, in-the-loop edits, prioritizing speed and responsiveness.
This duality caters to two distinct user workflows: asynchronous task completion and iterative, guided editing. The Smart Agent model was recently updated to Gemini 3, with the team actively optimizing its performance.
VII. UI Considerations: Editor vs. Terminal & Enabling Learning
AMP offers both an editor integration and a terminal UI, recognizing that each caters to different working styles. The editor experience focuses on reading code, with a custom diff viewer designed for agentic output. Features include editable diffs, code navigation, and a “tour of the change” to guide code review.
The terminal UI leverages modern terminal capabilities, including color rendering and graceful degradation for compatibility with various terminals.
The team emphasizes the need to make agentic coding accessible and facilitate learning. Features like thread sharing allow users to share prompting techniques and collaborate on problem-solving.
VIII. Accessibility & Economic Considerations: The Ad Network
Recognizing that cost is a significant barrier to entry, AMP has implemented a unique solution: a mini ad network delivering ads for other developer tools within the terminal and editor. This sponsorship effectively subsidizes inference costs for the Rush agent, making AMP more accessible to students and hobbyists.
IX. Community & Future Outlook
AMP is supported by a growing community of builders, fostered by Ryan Carson (formerly of Treehouse). The community focuses on experimentation, knowledge sharing, and exploring the potential of agents. The presenter highlights users like Mitchell Hashimoto (Ghosty) and Hamill Hussein (AI evals) as examples of the type of forward-thinking developers embracing AMP.
X. Conclusion
The presentation concludes by reiterating AMP’s unique approach to agentic coding, emphasizing its opinionated architecture, specialized sub-agents, and focus on enabling a new craft of development. The team encourages users to explore AMP and join the community to contribute to the future of AI-assisted coding.
AI summaries can miss context or contain errors. Check important details against the original video.
