Editor’s note: David vonThenen is a speaker for Odsc you have west this October 28-30 in San Francisco. Check out his talk, Rethinking RAG: How MCP and Agent2Agent Will Transform the Future of Intelligent Searchthere!

Retrieval-Augmented Generation (RAG) is one of the most essential patterns in AI today. It powers better search, sharper analytics, and smarter observability. RAG, or more importantly, the capabilities that RAG provides, are evolving, and at Odsc you have westI’ll be running a workshop called Rethinking RAG: How MCP and Multi-Agents Will Transform the Future of Intelligent Search. The focus is on how AI agents are maturing, not just in capability but in how we engineer them, which borrows from proven practices from traditional software development.

This won’t just be a theory-heavy session. Since it’s a workshop, you’ll leave with working examples that you can bring back to your team. We’ll explore how Agent2Agent and the Model Context Protocol (MCP) unlock new ways to design, extend, and coordinate AI agents. By the end, you’ll have code, materials, and a clear path to build your own multi-agent solution.

AI Agents Like Software Libraries

One of the most significant shifts happening in AI right now is how we think about agents. Instead of being giant, monolithic systems, they’re starting to look more like software libraries. With Agent2Agenteach AI agent can be modular, focused on a single job, just like a DLL in Windows or a shared object in Linux. This modularity makes agents easier to build, test, and, more importantly, reuse.

The power of this approach lies in the fact that agents don’t have to do everything themselves. If one agent specializes in parsing documents and another specializes in understanding your business’s inventory, they can work together. An agent can simply hand off work to another agent that’s better suited for the task. That means systems can be more efficient, more accurate, and easier to scale.

For the first time, these agents can also be decentralized. Instead of one large model being responsible for every step, you can utilize a network of smaller, specialized agents. Each plays its role, and together they create a system that’s more resilient and adaptable.

And just like software libraries, agents can be composed into bigger solutions. Need a system that answers legal questions? Combine a document retrieval agent, a summarization agent, and a reasoning agent. The result is something you can extend, improve, or even swap out without having to rebuild the entire system.

Extensibility and Customization via MCP

If modularity makes agents more like software libraries, Model Context Protocol (MCP) is what makes them extensible. Until now, most AI systems (this includes RAG Agents) have been limited to the data the original model was trained on. With MCP, we can finally extend an agent’s capabilities by connecting it to new data sources or tools without retraining the model itself.

This extension is dynamic. You don’t need to rebuild the entire pipeline every time you want to add functionality or a new corpus of data. Instead, you can plug in new capabilities as needed. Think of it like adding a new API integration: the agent doesn’t just know more, it can actually do more.

That means AI agents can move beyond simple read operations and start performing actions. Imagine asking an agent to purchase concert tickets on Ticketmaster or schedule a meeting directly in your calendar. These aren’t hypothetical scenarios; they’re precisely the kinds of workflows MCP makes possible.

And the best part? All of this happens through a natural language interface. You don’t need to write specialized scripts or handle brittle integrations. You can simply ask the agent in plain English (or your language of choice), and MCP takes care of the rest. This opens the door for highly customized, task-specific AI systems that are easier to build and much more powerful in practice.

Pitfalls, Perils, and Possibilities

As exciting as these advancements are, they come with real challenges. A recent MIT study found that 95% of AI pilots fail before ever reaching production. The reasons often aren’t about raw capability but about governance, observability, and trust. Just because an agent can do something doesn’t mean it should, especially considering the current landscape and frameworks in AI infrastructure.

Take write operations, for example. An agent that can purchase a concert ticket could also accidentally drain a credit card if permissions and access controls aren’t in place. If the implementation is poor, you might even purchase these tickets for a bad actor who knows how to exploit the system. Security concerns aren’t just theoretical… they’re the reason many teams hesitate to let agents perform real-world actions.

Another risk is observability. Multi-agent systems can start to look like black boxes, with decisions being passed from one agent to another in ways that are hard to trace. Without visibility, it’s tough to debug errors, measure accuracy, or even explain why a system made a particular decision. That lack of transparency makes adoption risky in industries where compliance and accountability are non-negotiable.

At the same time, tools like Agent2Agent and MCP shift how we approach training. Traditional RAG agents often required costly retraining just to handle new data or functionality. With modular agents and dynamic extensions, we can reduce that reliance. Instead of retraining a monolithic model or RAG Agents, we plug in the right agent or context at the right time. This lowers friction, but it also raises the stakes: we’re trading training complexity for integration complexity, and that demands a stricter understanding of what our agents are doing and what information they are accessing.

Conclusion

If agents can now collaborate through Agent2Agent and extend their functionality on the fly with Model Context Protocol (MCP)it’s fair to ask: do we even need RAG agents anymore? The answer is more nuanced than yes or no. RAG is still a powerful pattern for grounding responses in external knowledge, but it’s no longer the only option. Multi-agent systems and MCP shift the conversation from retrieval-first to capability-first—where agents can decide when and how to bring in information, and even act on it.

This shift reframes RAG as one tool in a larger toolkit rather than the foundation for every AI workflow. In our workshop, Rethinking RAG: How MCP and Multi-Agents Will Transform the Future of Intelligent Searchwe’ll explore this transition in depth. You’ll see how to combine these patterns, when RAG still matters, and when Agent2Agent and MCP open up better paths forward. If you want more details and an understanding of the implications… I invite you to attend my workshop, where we will answer that question, continue this conversation, and delve into the details.

The session is tentatively scheduled for Thursday, October 30 at Odsc you have west. Come ready with your laptop and the [prerequisite software installed from the Official Workshop Repo, and you’ll walk away prepared to build and experiment with the next generation of intelligent agents.

About the Author/ODSC AI West Speaker

David is a Senior AI/ML Engineer within the Office of the CTO at NetApp, where he’s dedicated to empowering developers to build, scale, and deploy AI/ML solutions in production environments. He brings deep expertise in building and training models for applications like NLP, vision, real-time analytics, and even models to classify diseases in a medical setting. His mission is to help users build, train, and deploy AI models efficiently, making advanced machine learning accessible to users of all levels.