The Video Signal

Topic

Model Context Protocol (MCP)

All digests tagged Model Context Protocol (MCP)

Designing REST APIs for the age of AI agents - Boyan Mihaylov - NDC Copenhagen 2026 thumbnail

· 43:22

Designing REST APIs for the age of AI agents - Boyan Mihaylov - NDC Copenhagen 2026

The talk argues that REST APIs, originally designed for human developers, must fundamentally adapt to serve AI agents and LLMs as primary consumers. To ensure reliability and discoverability in an AI-driven world, API designers must focus on structured documentation (OpenAPI), robust error handling, maintaining consistency, implementing adaptive rate limiting, and considering new standards like the Model Context Protocol (MCP) for web integration.

Key takeaways

  1. AI Agents are a New Consumer 21:45

    The rise of AI tools means that API consumers are shifting from human developers to autonomous agents. These agents will interact with APIs by generating requests and chaining calls, requiring the API to be machine-readable and reliable.

  2. Documentation is Critical for AI 26:45

    The OpenAPI standard (JSON or YAML specification) is crucial. Beyond simply documenting endpoints, developers must add rich metadata about the API's purpose, constraints, and potential errors to minimize agent hallucination.

  3. Prioritize Error Handling 30:30

    Instead of basic validation messages, provide detailed error information (e.g., specifying the problematic field and supported options) to allow AI agents to self-correct and retry requests effectively.

  4. Adopt Adaptive Rate Limiting 35:05

    Traditional static rate limiting (e.g., fixed quotas per minute) is insufficient for unpredictable AI agent traffic. Implement adaptive strategies that analyze traffic patterns and adjust limits dynamically to maintain service availability.

  5. Consider Web MCP 40:05

    For web-based services, the Model Context Protocol (MCP) is an emerging standard allowing a webpage itself to expose tools and workflows directly to AI agents, making the entire page functional rather than just relying on backend APIs.

Watch on YouTube Full article

Tour of Agent Protocols: MCP, A2A, AG-UI, A2UI - Mete Atamel - NDC Copenhagen 2026 thumbnail

· 53:45

Tour of Agent Protocols: MCP, A2A, AG-UI, A2UI - Mete Atamel - NDC Copenhagen 2026

The talk provides a deep technical overview of four emerging protocols designed to standardize communication and interaction within complex AI agent systems: Model Context Protocol (MCP), Agent-to-Agent Protocol (A2A), Agent-User Interface Protocol (AG-UI), and Agent-to-UI Protocol (A2UI). These standards address the challenges of building interoperable agents that can access external tools, communicate with other agents across diverse frameworks, and generate rich user interfaces.

Key takeaways

  1. MCP Standardizes Tool/Context Access 18:03

    MCP standardizes how Large Language Models (LLMs) access external functions (tools) and data (resources). Instead of one-to-one integrations, tools are wrapped into MCP servers, which can be accessed by an AI application via an MCP client. This architecture supports local (Standard IO) or remote (streamable HTTP transport) deployments.

  2. A2A Enables Inter-Agent Communication 23:50

    A2A is an open protocol defining how agents running on different frameworks communicate. Agents expose their capabilities via a JSON metadata file called the 'agent card,' which details skills (functions), contact methods, and authentication schemes.

  3. AG-UI Standardizes Agent State Streaming 29:40

    AG-UI is an event-based protocol designed to standardize how agent backends stream state updates to frontends, connecting the AI logic layer to the user interface.

  4. A2UI Standardizes Generative UI Output 32:30

    A2UI is a generative protocol that standardizes how agents generate functional User Interface (UI) components (using JSON structures), moving beyond simple text or data output. It defines core messages like `create surface`, `update components`, and `update data model`.

Watch on YouTube Full article

Let's build an AI agent - Phil Nash - NDC Copenhagen 2026 thumbnail

· 49:59

Let's build an AI agent - Phil Nash - NDC Copenhagen 2026

This talk demystifies AI agents by building one from scratch, demonstrating how Large Language Models (LLMs), tools, and memory work together in a continuous loop to achieve goals. The core mechanism involves an agent runtime that orchestrates function calls—allowing the LLM to interact with external systems like file systems or calculators. Advanced concepts covered include the Model Context Protocol (MCP) for standardized tool interaction and 'Skills' for progressive disclosure of capabilities, enabling agents to perform complex tasks like self-refactoring.

Key takeaways

  1. Agent Architecture 17:03

    An agent fundamentally runs tools in a loop to achieve a goal. This process requires an LLM, external tools (functions), and an orchestration layer (the 'harness') that manages the interaction.

  2. The Agent Loop 28:10

    The core agent functionality is implemented in a loop: The model generates function calls $\rightarrow$ The harness executes those functions (awaiting results) $ ightarrow$ The results are fed back to the model for the next step, continuing until the goal is met.

  3. Standardization via MCP 36:00

    The Model Context Protocol (MCP) provides a standardized way for agents to interact with services. It separates concerns into Server components (tools, resources, prompts) and Client components.

  4. Progressive Disclosure with Skills 40:05

    Skills allow for progressive disclosure of capabilities. Instead of loading all tool declarations at once, the agent only loads a skill's header initially and can request more details (resources, scripts) as needed.

Watch on YouTube Full article