MCP-style interfaces (like Model Control Protocol) are going to be critical for orchestrating intelligent, multi-agent systems in a flexible, language-driven, and composable way.
Let’s unpack both where we’re going and what’s still needed to get there.
Where We’re Going: The Agentic Future
- Language as an Interface Layer
- With models like GPT-4/5 and Claude operating at a super high level, we need unified glue—and language is that glue.
- MCP or similar protocols become a universal abstraction over API calls, CLI tools, data pipelines, etc.
- With models like GPT-4/5 and Claude operating at a super high level, we need unified glue—and language is that glue.
- Vibe Coding & Natural Command Flow
- “Vibe Coding” will mean expressing intent, not syntax.
- The LLM interprets vibes/intents and composes the tools (via MCP or similar layers) to get the job done.
- “Vibe Coding” will mean expressing intent, not syntax.
- Autonomous + Semi-Autonomous Agent Systems
- Agents don’t just “do a thing.” They decide what to do, iterate, handle failures, and report back.
- MCP acts like the ROS (Robot Operating System) of LLMs—standardizing how these agents talk, think, and act.
- Agents don’t just “do a thing.” They decide what to do, iterate, handle failures, and report back.
- Multi-Agent Collaboration
- Teams of LLM agents coordinating via MCP-style channels.
- Think of one agent handling retrieval, another handling synthesis, another validating output, etc.—like microservices but all driven by prompts and context.
- Teams of LLM agents coordinating via MCP-style channels.
- Event-Driven Context Sync
- SSE (Server-Sent Events) or WebSockets keep real-time sync between agent actions and UI/chat feedback loops.
- Especially useful for IDE-style or dev-tool integrations.
- SSE (Server-Sent Events) or WebSockets keep real-time sync between agent actions and UI/chat feedback loops.
What’s Needed to Get There
Here’s the hit list of what needs to be built/improved:
1. MCP Defaults + Frameworks
- Today: too raw.
- Need: opinionated frameworks that scaffold tools, context injection, and execution in a way devs can adopt fast.
- Think: “Create MCP App” starter CLI, standardized agent registries, etc.
2. Permissioned & Secure Execution
- Agents that can run curl, rm -rf, or even deploy code need guardrails.
- Sandbox systems and user-defined constraints (e.g. via policies or signed tool definitions) are crucial.
3. Tooling & Ecosystem
- Standard libraries of plug-and-play tools with typed interfaces, observability, and retries.
- Language around MCP should support “tool manifests” and declarative schemas.
4. Memory + Context Graphs
- Tools like LangGraph are getting closer, but we need a better standard for:
- Context management
- Ephemeral vs long-term memory
- Event logs that can be replayed or debugged
- Context management
5. Frontend UX for Agentic Flows
- We need interfaces that show the flow of agent decisions, like debugging tools for AI.
- Think: MCP Dashboard, agent trace visualizer, vibe timeline, etc.
6. Developer Ergonomics
- TypeScript/Deno, Python, Rust—whatever the flavor, we need:
- Easy hot-reload of tools
- Local-first agent sandboxes
- DevTools plugins
- Easy hot-reload of tools
Given our expertise, we will build the following, stay tuned:
- We are in a prime position to build the frameworks or standard operating environments for these agents.
- We could also create meta-agents that help scaffold, deploy, and debug other agents.
- If we lean into open-source or MVP toolkits here, we could define the developer experience layer—something like Next.js or Vercel for agents.