Ampcode — A Better Architecture for Coding Agents

After trying almost all the coding agents out there, I've found Ampcode to consistently get the work done with fewer back and forths with the model. So I decided to spend some time reverse engineering it.

Three Key Architectural Choices

Specialized sub-agents, not generalists

Most agents are overloaded with tools. AMPcode does the opposite: it composes a few specialists with deliberately limited toolsets.

• Librarian — Reads and searches files only. No execution, no writing. Pure information retrieval with laser focus.
• Search Agent — Finds patterns in code with several focused variants. Each optimized for different search strategies.
• Task Runner — Executes and coordinates results. Takes the findings from other agents and makes changes happen.

This constraint eliminates decision paralysis. Instead of "which of these 40 tools should I use?", each specialist only sees what's relevant and gets to work—faster and more accurately.

A unified tool interface across environments

Ampcode provides consistent tools that work across different contexts—whether you're working with local files or remote repositories.

The same read_file() command works regardless of where your code lives:

• Local filesystem — Direct file access for local development
• Remote repositories — Seamless integration via APIs

One consistent interface. The agent uses the same tools without switching contexts.

# Local file
content = read_file("src/main.py")

# Remote repository file
content = read_file("README.md")  # Works the same way

Multi-model collaboration

Ampcode uses multiple specialized models working together, each focused on specific tasks rather than one model handling everything.

They combine multiple models work in parallel and combine their strengths.

Example

• You describe a bug. The Search Squadron locates relevant functions and call sites.
• The Librarian fetches the exact files and diffs.
• The Task Runner applies the minimal edit and validates with targeted checks.
• Specialized models coordinate to handle edge cases before changes land.

Key lessons

• Constraints create clarity — Limited toolsets force better decisions
• Abstract away complexity — Unified interfaces hide implementation details
• Treat models as teammates, not competitors — Collaboration beats solo performance