What Is the Coding Agents Speaker Series?¶

I hosted a series of conversations with the teams behind the most successful coding agents in the industry—Cognition (Devin), Sourcegraph (Amp), Cline, and Augment. Coding agents are the most economically viable agents today—they're generating real revenue, being used daily by professional developers, and solving actual business problems at scale.

This makes them incredibly important to study. While other agent applications remain largely experimental, coding agents have crossed the chasm into production use. The patterns and principles these teams discovered aren't just theoretical—they're battle-tested insights from systems processing millions of real-world tasks.

This series captures those hard-won lessons, revealing what works and what doesn't when building agents that actually deliver economic value.

What Are the Key Insights?¶

The most striking pattern across all conversations is the retreat from complexity. Every team independently discovered that simpler approaches consistently outperform elaborate architectures:

• Grep beats embeddings for code search in most scenarios
• Single agents outperform multi-agent systems due to context coherence
• Direct exploration beats RAG for understanding codebases
• Simple tools with agentic loops surpass complex retrieval engines

This isn't about cutting corners—it's about letting model capabilities shine through rather than constraining them with unnecessary abstraraction layers.

What Key Terms Should I Know?¶

• Agentic Retrieval: Models deciding which tools to invoke to fetch context, rather than pre-computed retrieval
• Context Coherence: Maintaining narrative integrity throughout long coding sessions
• Tool-Calling Loops: Persistent agents that make multiple tool calls to build understanding
• Context Pollution: Noisy outputs from tools that crowd out useful reasoning context
• Sub-agents: Specialized agents for specific tasks (search, analysis) that preserve main agent context
• Plan and Act Paradigm: Agents that first explore and plan, then execute changes
• Context Engineering: Designing tool responses that teach agents how to navigate codebases
• Narrative Integrity: Following coherent thought processes rather than jumping between disconnected snippets
• The Bitter Lesson: As AI improves, complex application layers often become unnecessary overhead

How Have Coding Agents Evolved?¶

Early Era (2023): Simple completions with basic retrieval and low latency requirements

Chat Era (2024): More complex retrieval across multiple files with human-in-the-loop workflows

Agentic Era (2025): Highly autonomous systems that explore codebases independently and make changes with minimal supervision

The fundamental shift is from retrieval-first (fetch context, then reason) to exploration-first (reason about what to explore, then fetch). This inversion of control changes everything about how we build these systems.

What Posts Are in This Series?¶

1. Why Grep Beat Embeddings in Our SWE-Bench Agent (Lessons from Augment)¶

Speaker: Colin Flaherty (Augment)

Core thesis: Agent persistence can overcome limitations in retrieval tools. Simple grep and find tools with agentic loops often outperform complex embedding-based retrieval for coding tasks.

Key insight: Agents don't make traditional RAG obsolete—they change how we should think about retrieval. Instead of complex monolithic engines, provide portfolios of simple, composable tools.

Practical takeaway: Don't throw away existing retrieval systems. Expose them as tools to agents for the best of both approaches.

2. Why Cognition Does Not Use Multi-Agent Systems¶

Speaker: Walden Yan (Cognition)

Core thesis: Multi-agent systems fail due to context loss and conflicting decisions. The "telephone game" effect between agents creates more problems than benefits for coding tasks.

Key insight: True collaboration requires mentally modeling what other agents know—a sophisticated capability current models lack. Single agents with proper context management consistently outperform multi-agent setups.

Practical takeaway: Systems should feel like a single coherent entity to users. Focus on making single agents smarter rather than coordinating multiple agents.

3. Rethinking RAG Architecture for the Age of Agents¶

Speaker: Beyang Liu (Sourcegraph)

Core thesis: The shift from RAG chat to agentic systems requires rethinking everything—context management, tool design, model selection. Many best practices from the chat era are now counterproductive.

Key insight: The agentic paradigm inverts context fetching control. Instead of pre-computing what context to inject, models decide which tools to invoke. This seemingly minor change has profound implications.

Practical takeaway: Question cargo-culted assumptions from the chat era. Focus on composable Unix-like tools rather than vertically integrated solutions.

4. Why I Stopped Using RAG for Coding Agents (And You Should Too)¶

Speaker: Nik Pash (Cline)

Core thesis: Embedding-based RAG creates unnecessary complexity and security risks for coding agents. Direct exploration approaches that mirror human engineering workflows produce better results.

Key insight: The "bitter lesson" applies to coding agents—as models improve, complex application layers become overhead. Simple approaches that let model capabilities shine through consistently win.

Practical takeaway: Agents should explore codebases like humans do: examining folder structures, reading files, following imports, and building coherent understanding through discovery.

What Are the Common Patterns?¶

The Simplicity Advantage¶

Every successful coding agent team independently discovered that simpler approaches work better:

• Cline abandoned embedding-based RAG for direct exploration
• Augment found grep sufficient for SWE-Bench tasks
• Cognition chose single agents over multi-agent coordination
• Sourcegraph designed composable tools rather than monolithic systems

Context is King¶

All teams emphasize context management as the critical challenge:

• Maintaining narrative integrity throughout long sessions
• Avoiding context pollution from noisy tool outputs
• Using sub-agents to preserve main context window
• Implementing smart compaction strategies

Tool Design Matters¶

Successful agents use thoughtfully designed tool portfolios:

• Simple, composable tools over complex integrations
• Structured outputs that guide agent reasoning
• Clear separation between exploration and execution phases
• Unix philosophy of doing one thing well

How Should I Use This Series?¶

If you're building coding agents: 1. Start with Why I Stopped Using RAG to understand why simple approaches win 2. Read Cognition's multi-agent lessons to avoid coordination pitfalls
3. Study Sourcegraph's architecture principles for design guidelines 4. Review Augment's retrieval insights for tool selection strategy

If you're evaluating coding agents: - Focus on how agents handle context coherence in long sessions - Evaluate tool simplicity and composability over feature complexity
- Test performance on real codebases, not synthetic benchmarks - Prioritize systems that feel like coherent single entities

If you're researching agent architectures: - Study how successful teams balance autonomy with user control - Investigate context management strategies beyond simple compaction - Explore the economics of different tool design approaches - Consider how these patterns might apply beyond coding domains

Who Is This Series For?¶

• Engineering teams building or evaluating coding agents
• Product leaders understanding the ROI of AI-assisted development
• AI researchers studying agent architecture and tool design
• Developers curious about how these systems actually work in practice

Each conversation includes specific implementation details, real-world metrics, and honest assessments of what works and what doesn't in production environments.

What's the Future of Coding Agents?¶

Based on these conversations, coding agents are evolving toward:

Simpler architectures that let model capabilities shine through rather than constraining them

Better context engineering that maintains coherence across long development sessions

Composable tool ecosystems following Unix principles of modularity and reuse

Tighter human-agent collaboration with appropriate escalation and confidence signaling

Domain expansion as patterns proven in coding extend to other structured knowledge work

The teams building these systems are still discovering fundamental principles that will likely become standard practice within a few years. This series captures that learning in real-time.

How Do I Get Started?¶

Begin with Nik Pash's perspective on RAG to understand the core philosophy shift, then explore the specific architectural insights from each team based on your current implementation needs.

The future of coding isn't just about AI writing code—it's about AI understanding and navigating the complex, structured information spaces that real software development requires. These conversations show us how to build that future effectively.

Want to Learn More?¶

I know these conversations cover a lot of ground—from architectural decisions to business strategy. I try to capture what I learn from working with these teams, but sometimes having someone walk you through it can be more helpful. If you're building similar systems and want some guidance, I do both consulting and training:

Free 6-Week RAG Email Course Maven RAG Playbook — 20% off with code EBOOK