The software engineering bottleneck has shifted from the speed of code generation to the speed of human verification, necessitating a transition from text editors to agentic review platforms.
The Failure of Generic Tooling
- Beyang Liu argues that the current industry obsession with the Model Context Protocol (MCP)—a standardized way to connect AI to data sources—is insufficient for high-performance agents.
- Generic MCP servers lack the specific tool descriptions required for an agent to close complex feedback loops effectively.
- Cramming excessive tools into a prompt causes context confusion, where the model struggles to select the correct action from a bloated list.
- Amp prioritizes a custom, refined toolset over broad integrations to maintain a high signal-to-noise ratio during execution.
- Effective agents require tools tuned specifically to their internal logic rather than one-size-fits-all plugins.
“The creator of the MCP server doesn't know what your agent is trying to do, so they won't tune the tool descriptions to what you're trying to accomplish.” — Beyang Liu
Sub-agents as Context Management
- Liu identifies context exhaustion—where information gathering consumes the entire token limit before editing begins—as the primary cause of the "doom loop" failure mode.
- Sub-agents function like subroutines (isolated code blocks) in traditional programming, allowing the system to factor out specific tasks into separate context windows.
- The "Finder" sub-agent utilizes small, high-speed models to locate relevant code, returning only the essential snippets to the main agent.
- The "Oracle" sub-agent handles deep reasoning and planning, allowing the main agent to remain responsive while the Oracle performs chain-of-thought analysis on complex bugs.
- The "Kraken" sub-agent executes large-scale refactors via code mods (automated scripts that transform code across multiple files) instead of manual file-by-file edits.
“Sub-agents are effectively a way to conserve and extend the context window of your main agent.” — Beyang Liu
The Death of the Model Selector
- Amp rejects the standard industry UX of allowing users to toggle between different Large Language Models (LLMs), claiming this "paradox of choice" hinders architectural optimization.
- Providing a list of models prevents developers from deeply optimizing the agent harness for the specific quirks and strengths of a single frontier model.
- Amp utilizes a dual-agent architecture: a "Smart" agent for complex planning and a "Rush" agent for low-latency, inner-loop edits.
- The team recently migrated the Smart agent to Gemini 1.5 Pro (referred to as Gemini 3) after intensive testing showed it moved the frontier of agentic capability.
- Specialization beats generalization; an agent tuned for one specific model outperforms a generic wrapper attempting to support every available API.
“We just don't think that [model selection] is the architecture of the future.” — Beyang Liu
The Editor as a Reading Interface
- As agents take over the bulk of code production, the human developer's primary workspace must evolve from a writing tool into a high-fidelity review environment.
- Developers now spend the majority of their time performing code review within the editor rather than manual typing.
- Amp’s custom diff viewer (a tool showing line-by-line changes) provides guided "tours" of agentic output to help humans understand the intent behind multi-file changes.
- The system integrates with modern GPU-accelerated terminals like Ghosty to provide a high-performance Terminal User Interface (TUI) that streams diffs in real-time.
- The goal is to enable developers to parallelize their work by managing multiple agents simultaneously through a streamlined verification UI.
“I think of my editor now more as a reader more than anything else because I don't think you're really editing all that much anymore.” — Beyang Liu
Ad-Sponsored Inference and Economic Access
- High inference costs (the price of running a model) remain a significant barrier to the mass adoption of agentic workflows, particularly for students and independent developers.
- Amp is experimenting with a non-intrusive ad network within the terminal to sponsor the cost of the "Rush" agent.
- This model aims to make frontier-grade coding agents accessible to users who cannot afford high monthly subscription fees.
- The strategy focuses on organic growth and community building among "weirdo" power users rather than traditional paid influencer marketing.
- Lowering the economic barrier allows for a wider feedback loop from the next generation of developers who are "learning the craft" alongside AI.
“One of the biggest barriers to using agents fully is actually cost right now.” — Beyang Liu
Investor & Researcher Alpha
- The New Bottleneck: Capital is shifting from "generation" (writing code) to "verification" (reviewing code). Startups building superior diff-viewing, testing, and automated verification UIs will capture the value that generic "copilots" are losing.
- Modular Context: The "one big context window" approach is inefficient. Research is moving toward multi-agent architectures that use specialized sub-agents to prune information, effectively creating a "virtual" infinite context.
- Economic Pivot: Ad-supported inference suggests a "Free-to-Play" future for development environments. This could disrupt the SaaS subscription model for developer tools, favoring platforms that can monetize the "eyeballs" of developers during the high-frequency agent review process.
Strategic Conclusion
Software engineering has transitioned into a supervisory role. Success now depends on mastering agent orchestration and high-speed verification rather than syntax. The industry must move from generic LLM wrappers to opinionated, multi-agent systems that treat context as a finite, manageable resource.
Next Step: Shift R&D focus from "model choice" to "agentic UI" and "automated verification."
