Model Context Protocol (MCP) — The Video Signal

Sep 9, 2026 · 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

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.
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.
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

Sep 6, 2026 · 8:49

AI Simplified: 6 Concepts You Need to Know About Modern AI

The video simplifies modern AI by detailing six essential concepts: Large Language Models (LLMs), Model Training/Tuning, Retrieval Augmented Generation (RAG), AI Agents, Model Context Protocol (MCP), and System Prompts. The explanation uses human analogies to show how these components—from the core 'brain' (LLM) to the 'central nervous system' (MCP)—are integrated to create sophisticated systems capable of reasoning, accessing external knowledge, and taking autonomous actions.

Key takeaways

Artificial Intelligence (AI)
A subfield of computer science focused on matching or exceeding human intelligence in a machine. The core function is generating content using probabilities to predict output based on input, described as 'autocomplete on steroids.'
Large Language Models (LLMs)
The foundational component or 'brain' of the AI system where core intelligence and reasoning capabilities reside. It is responsible for generative AI outputs (words, images, sounds).
RAG (Retrieval Augmented Generation) 3:35
A method to extend the LLM's knowledge base by integrating trusted external sources (e.g., research papers or product documentation). This process helps reduce 'hallucinations'—confident errors made by the AI.
AI Agents 5:20
An advanced system where a model autonomously uses external tools (e.g., writing code, searching the web, reading/writing databases) to achieve specific goals, giving the AI 'hands and feet.'
Model Context Protocol (MCP) 6:20
The orchestration layer that acts as the central nervous system for an AI agent. MCP connects the model's reasoning to the external tools, coordinating actions.
System Prompts 7:30
A set of guiding principles or constraints given to the model that dictates its behavior and ethical boundaries. This prevents misuse (like prompt injections) without requiring constant, expensive retraining.

Watch on YouTube Full article

Aug 7, 2026 · 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

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.
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.
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.
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.
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

Aug 5, 2026 · 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

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.
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.
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.
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

Jul 6, 2026 · 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

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.
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.
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.
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