The Video Signal

Topic

Protocol Design

All digests tagged Protocol Design

Hugging Face's MCP Server: Only 62K of 10M Calls Matter thumbnail

· 9:44

Hugging Face's MCP Server: Only 62K of 10M Calls Matter

The video discusses the significant overhead and limitations inherent in current AI agent protocols, particularly the Model Call Protocol (MCP). Speakers highlight that complex agent interactions are often hampered by chatty, stateful handshakes and reliance on visual/pixel-based inference (the 'guessing game'). Solutions proposed include implementing Web MCP, which allows front ends to expose capabilities rather than just pixels, and building robust guardrails and validation logic directly into the protocol's plumbing (using lifecycle hooks) to prevent agents from reinventing existing components or making unauthorized calls.

Key takeaways

  1. Protocol Overhead is High 2:07

    A stateful MCP handshake is highly chatty. For every 10 million protocol messages, 1.2 million are 'initialize' events, but only 62,000 are actual tool calls, indicating significant protocol overhead (00:02:07).

  2. Web MCP Shifts Focus from Pixels to Capabilities 2:32

    Current web agents operate by observing screenshots, DOM, or accessibility trees, which is inefficient and consumes excessive tokens. Web MCP proposes letting the front end expose defined capabilities instead of relying on pixel-level guessing (00:02:32).

  3. Guardrails Must Live in the Plumbing 4:57

    Since developers cannot control what an LLM agent decides to call, guardrails must be implemented in the protocol's plumbing (e.g., using lifecycle hooks before or after a tool call) to validate outputs, such as ensuring an email is in a client's custom domain (00:04:57).

Watch on YouTube Full article

Generative UI... in Python? — Jeremiah Lowin, Prefect thumbnail

· 17:38

Generative UI... in Python? — Jeremiah Lowin, Prefect

This talk introduces Prefect, a Python DSL designed to solve the challenge of delivering rich, interactive UIs within the MCP (Messaging/Communication Protocol) ecosystem. While MCP apps allow tools to bypass the agent and render full HTML/CSS/JS interfaces, the primary user base (Python engineers in enterprises) needed a way to build these UIs without writing complex frontend code. Prefect achieves this by allowing developers to compose UIs using Python context managers and classes, which are then serialized into a JSON protocol and rendered by a React app. A key optimization is streaming the Python code itself over the wire and executing it in a sandbox, resulting in a 70% reduction in size compared to streaming the JSON representation.

Key takeaways

  1. MCP Apps and Agent Bypass

    MCP apps are an extension of the MCP protocol that allows tool results to bypass the agent and be delivered directly to the user as a full UI (HTML, CSS, JavaScript), enabling rich, interactive experiences.

  2. The Prefect Solution 9:03

    Prefect is a Python DSL that allows developers to compose UIs by nesting components using context managers, avoiding the need to write traditional frontend code.

  3. The Core Pipeline 10:37

    The process involves using a Python DSL to build a declarative representation, which is serialized into a JSON protocol. This JSON is then rendered by a React app hosted as the MCP app.

  4. Efficiency Improvement 16:40

    The system was optimized to stream the Python representation of the UI over the wire and execute it in a sandbox, which was found to be approximately 70% smaller and more efficient than streaming the full JSON protocol.

Watch on YouTube Full article

The Universal Remote Control for AI — Alex Hancock, Block thumbnail

· 11:01

The Universal Remote Control for AI — Alex Hancock, Block

The talk addresses the lack of a standardized client-to-harness interface in the agentic AI stack. While the Model Context Protocol (MCP) provides a strong standard for agents performing actions (the agent going out), a standard for client software to issue tasks and receive updates is missing, leading to bespoke, non-interoperable systems. The speaker proposes the Agent Client Protocol (ACP), developed by the Zed and JetBrains teams, which standardizes communication using JSON RPC. ACP allows multiple, independent client applications (e.g., editors, terminal clients) to drive the same agent harness, significantly increasing interoperability and enabling the modular placement of the four core components: client, harness, tools, and model, especially when remote transports are implemented.

Key takeaways

  1. The Need for Client Standardization 2:03

    Currently, many agent harnesses expose custom or bespoke interfaces, often requiring a single, dedicated client application. This lack of a universal standard hinders interoperability, comparing it to needing a different browser for every website.

  2. ACP as the Universal Remote Control 5:02

    The Agent Client Protocol (ACP) was developed to allow a single, high-quality client implementation (like an editor) to control any harness, regardless of the underlying system. It is designed to be neutral and extensible.

  3. Modular Agentic Stack Architecture

    By implementing remote transports for ACP, MCP, and model endpoints, the entire agentic stack becomes modular. The client, harness, tools, and model can all be independently placed (e.g., client on a desktop, harness in a container, model in the cloud).

Watch on YouTube Full article

Stateless, Yet Durable: MCP Tasks v2 thumbnail

· 26:23

Stateless, Yet Durable: MCP Tasks v2

The session details MCP Tasks v2, an architectural evolution designed to enable durable, long-running workflows while maintaining a fundamentally stateless protocol design. Using Purchase Order processing as a concrete example, the talk contrasts the complexity and scalability issues of V1 (which relied on stateful server tracking and polling) with the simplified V2 approach. The key shift involves moving client responsibility for task ID persistence to durable storage and introducing a future notification mechanism to replace inefficient constant polling.

Key takeaways

  1. MCP Tasks v2 Simplification 17:53

    V2 eliminated the complex `task list` functionality (due to scalability concerns) and significantly changed how elicitation flows, simplifying the client-server protocol into basic polling and an explicit `update` API.

  2. Durability vs. Statelessness 4:28

    While the MCP protocol is stateless, the tasks themselves are designed as durable state machines (e.g., invoice processing), requiring robust mechanisms to track their lifecycle states (Working, Input Required, Terminal).

  3. Scaling Beyond Polling 23:50

    For massive scale (millions of tasks), constant polling is inefficient. The future direction involves implementing a notifications mechanism within the MCP Tasks protocol to allow idle tasks to consume zero resources until an event occurs.

Watch on YouTube Full article

MCP Release Overview: Stateless and the Big Changes in the New Spec thumbnail

· 17:48

MCP Release Overview: Stateless and the Big Changes in the New Spec

The latest MCP specification introduces a major architectural shift toward statelessness, fundamentally changing how clients and servers interact. This transition addresses scalability issues inherent in previous stateful designs by ensuring every client request contains all necessary information for the server instance to process it independently. Key updates include Multi Roundtrip Requests (MRTR) for complex flows, formalizing extensions (like MCP Apps and Tasks), and enhancing authorization adherence.

Key takeaways

  1. Transition to Stateless Architecture 3:50

    MCP is moving from a stateful model that relied on session IDs and retained server-side state (requiring an `initialize` call) to a fully stateless design. This eliminates the need for complex shared session stores or sticky load balancing, enabling easier horizontal scaling across multiple server instances.

  2. Multi Roundtrip Requests (MRTR) 7:30

    MRTR simplifies complex tool calls by breaking them into multiple, discrete requests rather than relying on open streams and waiting for responses. This significantly reduces architectural overhead when deploying services behind load balancers.

  3. Formalized Extensions 9:40

    The protocol now supports formal extensions, allowing developers to add specialized functionality without modifying the core spec. Key examples include MCP Apps (for delivering rendered UI) and Tasks (for modeling long-running processes like database migrations or human-in-the-loop workflows).

  4. Authorization Improvements 12:40

    The specification enhances adherence to OAuth standards, requiring authorization servers to return the `iss` parameter. Clients must validate this before redeeming a code.

Watch on YouTube Full article

MCP Tasks (async): Why Aren't Any Agents Supporting Them? — Cornelia Davis, Temporal thumbnail

· 23:54

MCP Tasks (async): Why Aren't Any Agents Supporting Them? — Cornelia Davis, Temporal

Cornelia Davis discusses MCP Tasks, a specification designed to enable durable, long-running asynchronous interactions for tools and agents that cannot complete in a single request/response cycle. The core challenge is maintaining state and functionality across infrastructure failures (network blips, process crashes) or human delays. While the initial V1 protocol was complex and stateful, the evolution to V2 significantly improves scalability by moving toward a stateless core and structured extensions, making it more viable for large-scale distributed systems.

Key takeaways

  1. The Problem of Long-Running Tasks

    Traditional request/response models fail when work takes time. MCP tasks solve this by allowing an agent to invoke a tool, receive a handle, and interact with that handle asynchronously, surviving disconnections and crashes.

  2. Durability is Paramount 6:43

    For the task to be reliable, it must be durable—meaning its state survives client disconnects, server outages, or human delays. This requirement adds significant complexity.

  3. V2 Moves Toward Statelessness 17:15

    The major improvement in the MCP Tasks V2 specification is its move toward a stateless core and structured extensions, addressing the inherent difficulties of managing stateful protocols in large-scale distributed systems.

Watch on YouTube Full article