What an Anthropic Engineer Thinks About MCP

The podcast discusses the evolution and maturity of SDKs and the Multi-Call Protocol (MCP), highlighting a major update that transitions MCP from a stateful to a stateless protocol to improve scalability. This change, inspired by challenges faced at hyperscale companies like Microsoft, Google, and Anthropic, addresses issues such as load balancing, state synchronization, and latency by eliminating the need for session persistence. To maintain functionality while embracing statelessness, the protocol now uses multi-round-trip mechanisms and ensures that all context is transmitted with each request, enabling better caching and distribution across servers.

The discussion also covers design philosophies such as minimal viable solutions, progressive disclosure, and the trade-offs between core stability and extensibility. Emphasis is placed on reducing context bloat through techniques like tool search and programmatic tool calling, as seen in implementations by Cloudflare and Anthropic. The protocol's design prioritizes composability, universality, and long-term stability for core features, while allowing innovations to mature as extensions before potential integration. Observability, tracing via Open Telemetry, and future challenges around compliance and governance are also explored, with a vision for a stable core protocol supported by a flexible extension system shaped by community feedback.

• What if you built a stateless AI tool server using the new MCP spec today?

  • Move: Refactor your existing agent API to eliminate session persistence, encode all context in requests/responses, and use the latest TypeScript/Python SDK to implement a stateless endpoint.
  • Why Now?: The new MCP release (v2) enables stateless operation with multi-round-trip workflows, and SDKs now support it with minimal code changes - making migration faster than ever.
  • Expected Upside: Scale to millions of concurrent users without load-balancer affinity or Redis-backed sessions, reducing infra cost and complexity by up to 40% while improving latency.

• What if you shipped a micro-SDK for a niche use case as an extension before pushing it to core?

  • Move: Identify a high-friction workflow in your product (e.g., financial compliance or real-time rendering), build a standalone extension using MCP's extensibility model, and publish it with usage telemetry.
  • Why Now?: The ecosystem now supports mature SDKs and extension patterns that allow fast iteration without destabilizing core protocol adoption.
  • Expected Upside: Achieve product-market fit 2 - 3x faster by validating demand before contributing to core, avoiding wasted effort on prematurely generalized features.

• What if you eliminated context bloat in your agent app by implementing tool search and code-gen today?

  • Move: Replace full tool spec injection with a searchable tool index and allow models to generate executable scripts (e.g., JS blocks) instead of single tool calls - just like Cloudflare and Anthropic.
  • Why Now?: Models now handle dynamic tool discovery robustly, and token costs remain high enough that naive context usage cripples performance at scale.
  • Expected Upside: Reduce average request token count by 50 - 70%, lowering costs, increasing throughput, and enabling longer-running agent tasks without hitting context limits.

• Upgrade to the latest MCP SDKs (TypeScript, Python, C#) to leverage the stateless protocol update with minimal code changes and ensure future compatibility.
• Design new features as extensions rather than modifying the core protocol to enable faster iteration and reduce the risk of breaking changes.
• Implement tool search and programmatic tool calling in client-side logic to reduce context bloat and improve token efficiency in model interactions.
• Integrate Open Telemetry into MCP server implementations for better observability and tracing across multi-server agent workflows.
• Submit feedback and use cases to the open-source project to influence the development of extensions and help shape next-phase protocol standards.