Presenters

Source

The Agent Ecosystem: From Demos to Production-Ready Connectivity 🚀

Hey tech enthusiasts! David Soria Parra here, and I’m buzzing with excitement about the incredible evolution of the agent ecosystem. We’ve come a long way from simple specs and local tools to a vibrant, production-ready landscape. Let’s dive into what’s happening and where we’re headed!

MCP Applications: Shipping Intelligence, Not Just Code 💡

Imagine an agent that ships its own interface, not as a plugin or a hardcoded feature, but as a fully functional application served over an MCP server. This is the power of MCP applications! You can take this server, deploy it anywhere – the cloud, ChatGPT, VS Code Cursor – and it just works. This requires a crucial element: semantics. Both the client and the server need to understand each other, how to render the UI, and that an interface is indeed coming. This is where a robust protocol becomes essential.

But MCP servers offer even more! They don’t just ship apps; they can ship tools too. This means humans can interact with the application, and the model can interact with it through these tools. This dual interaction capability is a game-changer that we’re just beginning to explore.

From Humble Beginnings to 110 Million Downloads! 📈

Rewind about 18 months, and this entire ecosystem was just a spec document with a few SDKs, primarily local and focused on tools. Fast forward to today, and the pace of innovation has been insane!

  • Community Power: You, the community, have been building servers and a thriving ecosystem at an astonishing rate.
  • Core Enhancements: On our side, we’ve taken the local-only approach and added remote capabilities, centralized authorization, and new primitives like elicitation and tasks.
  • Protocol Evolution: We’ve also introduced experimental features to the protocol, like the MCP applications you just saw.

The result? We’ve hit a massive milestone: 110 million monthly downloads! This isn’t just us; it’s OpenAI’s agent SDK, Google’s ADK, LangChain, and thousands of other frameworks pulling MCP as a dependency. This signifies a common standard for inter-agent communication. For context, React, a hugely successful open-source project, took roughly double the time to reach this download volume!

Beyond Coding Agents: The Rise of General-Purpose AI 🌐

We’ve seen incredible servers built, from simple WhatsApp and Blender integrations to sophisticated SaaS connectors for Linear, Slack, and Notion. However, a significant portion of MCP server development has been behind closed doors, connecting enterprise systems to AI applications.

While 2024 was about demos and 2025 focused on coding agents (a relatively ideal scenario due to their local, verifiable nature), 2026 is about putting agents into production. The capabilities of AI models are expanding, ushering in an era of general agents capable of real knowledge worker tasks – think financial analysis, marketing strategy, and more.

These general agents don’t need local agents calling compilers. They need connectivity. They need to connect to multiple SaaS applications and shared drives. And here’s a critical point: connectivity isn’t a one-size-fits-all solution. There’s a vast connectivity stack, and the right tool for the right job is paramount.

The Agent’s Toolkit for 2026: Skills, MCP, and CLIs 🛠️

When building agents in 2026, consider these three core components:

  1. Skills: These are essentially domain knowledge and capture-specific capabilities packaged in simple, reusable files.
  2. CLIs (Command Line Interfaces): Excellent for local coding agents, CLIs allow for simple interaction and automatic discovery of capabilities. They’re particularly useful for tools like Git and GitHub, especially in sandboxed environments where code execution is assumed.
  3. MCP (Meta Communication Protocol): This is your connective tissue for scenarios requiring rich semantics, UIs for long-running tasks, resource management, platform independence, authorization, governance, and enterprise-grade features. MCP enables decoupled, platform-independent solutions and supports cutting-edge experiments like MCP applications and skills over MCP.

The most powerful agents in 2026 will seamlessly combine all these methods, not rely on just one.

Bridging the Gap: Client-Side Innovations 💻

We’re still building out the agent harness – the core that powers these connective parts. Two key client-side innovations are crucial:

  • Progressive Discovery: Instead of loading all tools into the context window (which can lead to bloat), we should use a progressive discovery pattern. This involves deferring tool loading until the model actually needs them. You can implement this by using tool search or by building a “tool loading tool” that allows the model to request and load tools on demand. This dramatically reduces context window usage, as seen in the Claude Code example where tool context usage was massively reduced.
  • Programmatic Tool Calling (Code Mode): This is about composing actions effectively. Instead of a model chaining multiple tool calls sequentially, which incurs latency and inference costs, we can leverage a “repple tool” or an execution environment (like a V8 isolate or a Lua interpreter). The model can then write and execute code to orchestrate these actions, composing them together far more efficiently. MCP’s structured output feature is invaluable here, providing type information that enables seamless composition. If structured output isn’t available, models can be prompted to extract and format data into the desired type.

Server-Side Evolution: Designing for Agents, Not Just APIs 📡

Server authors need to shift their mindset:

  • Design for Agents: Stop one-to-one conversions of REST APIs into MCP servers. Instead, design with agents in mind, mirroring how a human would interact with the system.
  • Execution Environments: Servers like Cloudflare’s MCP server provide execution environments instead of just tools, allowing models to orchestrate tasks directly, reducing token usage and latency.
  • Leverage MCP Semantics: Utilize MCP’s rich semantics, including MCP applications, skills over MCP, task primitives, and elicitations. These are capabilities that alternatives simply cannot match.

The Future of MCP: Core Improvements and Seamless Integration 🌟

We’re also working on core MCP improvements:

  • Scalable Transport: A proposal for a stateless transport protocol from Google will make MCP servers easier to scale, treating them like standard stateless REST servers for deployment on platforms like Cloud Run or Kubernetes. This is slated for June.
  • Asynchronous Task Primitive: This is essentially enabling agent-to-agent communication, with more clients being built to support an experimental version of the protocol.
  • SDK Enhancements: We’re releasing TypeScript SDK v2 and Python SDK v2, incorporating lessons learned from the past year. (Yes, the Python SDK is getting a much-needed overhaul!)
  • Ubiquitous Integration:
    • Cross-App Access: For enterprises, this feature, developed with identity providers, allows single sign-on across MCP servers once authenticated with a company identity provider (like Google or Okta).
    • Server Discovery: A new mechanism will allow automatic discovery of MCP servers on well-known URLs, enabling crawlers, browsers, and agents to find and utilize them. This is also expected in June with the next specification.
  • Extension Mechanisms: We’re leveraging MCP’s extension mechanisms for features like MCP applications (which may be web-based) and, excitingly, skills over MCP. This allows server authors to ship updated skills directly with the server, bypassing plugin registries.

The Vision for 2026: Connected Agents, Limitless Possibilities ✨

MCP is in excellent shape, and 2026 is the year we push agents towards full connectivity. MCP will continue to be a cornerstone. We encourage your feedback through our Discord and issue trackers – your input is vital to our continuous improvement.

The agents of 2026 won’t be limited to one technology. They will harness computer vision, CLIs, MCPs, and skills, enabling a vast array of capabilities to ship truly remarkable applications. The MCP application we recently shipped, which allows models to write graphs, is just a glimpse of what’s possible under the hood.

Let’s build the future of intelligent agents together!

Appendix