MCP & tools

This talk addresses the proliferation of AI tools and provides guidance on selecting the appropriate ones for specific tasks. It emphasizes understanding the capabilities and limitations of various tools to make informed decisions in AI development and product building. The core thesis revolves around strategic tool selection to enhance efficiency and effectiveness.

This talk introduces MCP apps, an evolution of the Model Context Protocol (MCP) that allows MCP servers to return UI components alongside JSON data. This enables richer, interactive experiences where AI agents can not only call tools but also display and interact with user interfaces directly within the chat. The presentation emphasizes the growing importance of MCP apps and the opportunities for developers to build and distribute them through emerging app stores.

This talk explores the technical reasons behind the double iFrame implementation used by ChatGPT and other MCP (Meta-Conversational Platform) applications to render third-party UIs. It delves into the security implications of Content Security Policy (CSP) and sandboxing, explaining why direct iFrame embedding or using source-doc attributes are problematic. The presentation highlights the double iFrame approach as a solution to isolate third-party code while enabling necessary functionalities.

This talk introduces WebMCP, a proposed web standard designed to simplify how AI agents interact with websites. Instead of agents relying on brittle methods like screen scraping, WebMCP allows websites to expose their functionalities as structured tools. This approach aims to significantly improve the performance and reliability of AI agents performing actions on behalf of users, ultimately creating better user experiences.

This talk explores building self-maintaining data collection pipelines using Large Language Models (LLMs) and specialized tools. It addresses the challenge of collecting large-scale data from websites, particularly those with anti-bot measures, by shifting from direct LLM parsing of every page to an agent-driven approach that builds and maintains scrapers. The core idea is to empower LLMs with the ability to create and manage the tools needed for data extraction, thereby saving significant computational resources and development time.

This talk introduces Model Context Protocol (MCP) apps, which enable server tools to return rich, interactive components directly within chat interfaces. MCP apps enhance user experience by allowing direct interaction with generated UIs, moving beyond simple text or emoji responses. This technology facilitates complex tasks like data exploration and e-commerce within a chat environment, improving efficiency and engagement.

This talk introduces Chrome DevTools for Agents, a purpose-built debugging tool for AI agents, drawing parallels to the widely used Chrome DevTools for human web developers. The core thesis is that agents, as a distinct user class, require specialized interfaces and debugging capabilities to overcome their limitations, such as processing vast amounts of data or understanding complex tool descriptions. The presentation emphasizes engineering lessons learned from building and deploying this tool, focusing on effectiveness, efficiency, discoverability, and trust.

This talk explores the evolution of generative UI for Multi-Component Platform (MCP) applications, moving beyond static components to more dynamic and collaborative interfaces. It posits that current AI models are capable of generating sophisticated UI code, prompting a re-evaluation of how users interact with AI-powered applications. The core thesis is that the future of generative UI lies in collaborative experiences rather than just component-based outputs.

This talk introduces WebMCP, a system that enables agents to interact with web content directly within the browser. It explores how existing browser primitives can be leveraged to transform websites into interactive canvases for AI agents, moving beyond simple chat interfaces to richer, embedded experiences. The core idea is to make web content accessible and actionable for agents, similar to how humans navigate and interact with websites.

This talk explores how to move beyond traditional code coverage metrics to ensure true functionality testing, especially in the context of AI-assisted development. It argues that while AI can increase code output, its true productivity gains are amplified by clean codebases and robust testing. The presentation introduces Playwright as a tool for end-to-end browser testing, demonstrating how it can be integrated with AI agents to accelerate development workflows, particularly within a test-driven development (TDD) framework.

This talk explores how to effectively guide AI agents when they interact with complex products like Superbase. It argues that while agents are capable of many tasks, they require specific guidance to handle novel situations, security protocols, and optimized workflows. The presentation introduces the concept of "skills" as a method to provide this guidance, demonstrating how they improve agent performance and safety, particularly when integrated with tool-calling capabilities.

This talk explores the burgeoning open-source AI agent ecosystem, emphasizing the accessibility and power of open models and tools. It highlights how advancements in Hugging Face's platform, including the Hub, Traces, Skills, and MCP tools, are democratizing the development and deployment of sophisticated AI agents. The core thesis is that open-source AI is rapidly catching up to and even surpassing closed-source alternatives, offering greater control, privacy, and customization for developers.

This talk introduces MCP apps, a standardized way for tools and companies to send their user interfaces directly into chat applications. Instead of relying on text-based responses, which can be suboptimal and strip away brand identity, MCP apps allow for interactive UI components to be embedded within platforms like ChatGPT and Claude. This approach aims to preserve existing UI/UX knowledge and branding while enabling a more seamless integration of external services into conversational AI experiences.

This talk addresses the friction of repeated authentication for Multi-Cloud Platform (MCP) tools, where users must consent to access for each tool individually. It introduces Cross-App Access (XAA), a solution that leverages an Identity Provider (IDP) to act as a trust intermediary. XAA enables MCP clients to obtain credentials for MCP servers without manual user intervention after an initial single sign-on, streamlining the user experience and improving security management for IT.

This talk addresses the challenge of providing AI agents with access to a vast number of APIs, a problem termed the Mega Context Problem (MCP). Traditional methods like bundling all tools into an agent's context window lead to an explosion of tokens, rendering them unusable. The speaker proposes that instead of dumping tools into context, agents should be empowered to write code against APIs, leveraging typed SDKs and secure execution environments.

This talk explores the evolution and future of the Message Communication Protocol (MCP), emphasizing its role in enabling agents to achieve full connectivity. The core thesis is that MCP is a crucial connective tissue, allowing agents to interact with various applications and services, moving beyond simple coding tasks to handle complex knowledge work. The future of agent development in 2026 hinges on seamless integration of MCP with other tools like CLIs and skills to achieve robust functionality.

This talk addresses the critical security and design considerations for Multi-modal Communication Protocol (MCP) servers intended for production environments. It argues that insecure or poorly designed MCP servers are vulnerable to exploitation by agentic AI systems. The presentation emphasizes that robust security and effective design are intertwined, advocating for a product engineering mindset when building interfaces for AI agents.

This talk explores strategies for effectively integrating and managing third-party tools within AI agent workflows, specifically focusing on Multi-Call Protocol (MCP) servers. It addresses the common challenges of generic tool descriptions, unexpected agent behavior, and potential performance degradation or security risks when using off-the-shelf tools. The presentation outlines a framework of five best practices to tailor these tools for specific use cases, ensuring agents perform as intended and applications remain stable.

This talk argues that MCP servers, which act as interfaces for AI agents, should be designed with agents' unique strengths and weaknesses in mind, rather than simply mirroring human-facing APIs. The core thesis is that agents have different needs regarding discovery, iteration, and context compared to humans, and MCP server design must account for these differences to create effective and usable interfaces.

This talk explores the automation of business processes using Large Language Models (LLMs) through two key protocols: A2A (Agent-to-Agent) and MCP (Model Context Protocol). A2A facilitates communication between remote agents, enabling specialization and parallel processing, while MCP acts as a standardized interface for agents to access context and tools, akin to a USB-C for AI. The workshop demonstrates how to integrate these protocols to build multi-agent systems triggered by webhooks, automating tasks like bug reporting and information dissemination.

This talk introduces GitHub Copilot's Agent Mode, an advanced feature designed for completing moderately complex tasks autonomously. It moves beyond simple code completion and chat interactions to enable deep, iterative engagement with an AI agent. The presentation highlights how Agent Mode can build entire applications from a readme file or perform significant refactoring, with the developer providing permission for actions like terminal interactions.

This talk explores how general intelligence in computing systems may emerge from the interaction of multiple agents, similar to how intelligence arises in biological systems or markets. The speaker posits that the Multi-agent Conversation Protocol (MCP) is a crucial development enabling agents to communicate and form an agentic mesh, facilitating the rise of an agentic economy where agents can discover and utilize services.

This talk argues that the Messaging, Communication, and Protocol (MCP) framework, particularly its tool-calling capabilities, can simplify complex agentic workflows. The speaker, Samuel Colvin, creator of Pydantic, suggests that many current approaches to agent-to-agent communication are overcomplicated and that MCP offers a more streamlined solution. The core idea is to leverage MCP's primitives, especially dynamic tool calling, to build more robust and efficient AI systems.

This talk explores the underutilized capabilities of the Model Contract Protocol (MCP) beyond basic tool calling. It highlights how embracing the full MCP specification can unlock richer, stateful interactions for AI agents. The presentation emphasizes that while many are shipping products quickly using only tools, the spec offers advanced features like dynamic discovery, resources, and sampling that enable more sophisticated agent behavior and development experiences.

David Cramer of Sentry discusses the current state of MCP (Model Communication Protocol), framing it as a pluggable architecture for agents. He emphasizes that while the concept is powerful, current implementations are often rough and require significant design effort. Cramer suggests that MCP's true value lies in its ability to integrate services into agent workflows, particularly for B2B SaaS companies, by providing context that LLMs can reason about.

This talk explores what it means for Model Communication Protocol (MCP) to be enterprise-ready, moving beyond basic tool-use capabilities to address the complexities of production environments. It highlights the evolution from simple chatbot interactions to sophisticated AI agents that require robust security, management, and scalability, particularly when integrating with internal enterprise systems. The core thesis is that while MCP offers a standardized way for AI to interact with external resources, achieving enterprise readiness involves overcoming significant challenges in authentication, authorization, and operational management.

This talk presents a case study and deep dive into building telemedicine support agents using LangGraph and MCP. The core thesis is that LLM-powered agents can significantly enhance flexibility and capability in healthcare support systems, moving beyond traditional software limitations. The system aims to provide scalable, automated patient support while maintaining human oversight for complex or sensitive situations.

This workshop introduces building intelligent autonomous AI systems using Amazon Nova Act and the Modern Communication Protocol (MCP). It focuses on a do-it-yourself approach, enabling developers to create agentic systems that can plan, act, and reason to achieve objectives. The session highlights how these agents can leverage tools, knowledge bases, and LLMs to tackle complex tasks, with a particular emphasis on browser automation and integrating various AI components.

This talk addresses the critical need for security in Multi-Call Protocol (MCP) servers, particularly for remote instances. It introduces a new draft specification that simplifies authorization by separating the MCP server's role from that of an authorization server. This approach aims to reduce the burden on developers by allowing them to leverage existing OAuth 2.0 libraries and identity providers, rather than implementing complex authorization logic themselves.

The increasing prevalence of Machine Communication Protocol (MCP) agents is creating an observability blind spot for developers. As agents utilize more tools via MCP, understanding their end-to-end execution becomes challenging. This talk introduces observable.tools as a manifesto to drive a community conversation around standardized, vendor-neutral MCP observability, advocating for the adoption of OpenTelemetry (otel) to address this growing issue.

This talk discusses the challenges and solutions for implementing and scaling Message Communication Protocol (MCP) clients within a large organization. It highlights how the rapid evolution of AI models capable of tool calling led to integration chaos, with duplicated functionality and inconsistent interfaces across services. The solution proposed is to standardize on MCP for providing model context, treating it as a plumbing layer for integrations rather than a competitive differentiator.

The Model Context Protocol (MCP) is an open-source, standardized protocol designed to give AI models agency by allowing them to interact with the outside world. Originating from the need to copy context from external sources into LLM context windows, MCP aims to enable models to reach a new level of usefulness and intelligence by facilitating tool calling and broader interaction capabilities. The protocol prioritizes server simplicity and encourages community contributions to evolve its standards and utility.

This talk introduces the Model Context Protocol (MCP) as a standardized interface for connecting Large Language Models (LLMs) to external tools and resources, aiming to simplify and enhance agent development. It posits that 2025 will be the year agents hit mass production, facilitated by advancements in LLM reasoning capabilities, the widespread adoption of MCP, and simpler agent architectures. The presentation also explores modeling agents as asynchronous workflows and exposing them as MCP servers for greater composability and scalability.

This talk addresses the common challenges of unreliability, slowness, and cost associated with current AI agents that interact with external tools. The core thesis is that instead of creating simple, low-level wrappers around APIs, tools should be imbued with more agency, becoming specialized agents themselves. This approach blurs the line between tools and agents, enabling agents to offload complex tasks to more capable, specialized entities for improved performance and reliability.

This talk argues that the current focus on Multi-Call Protocol (MCP) and tool calling for LLMs is limiting their potential. The speaker contends that LLMs are powerful code generators and language producers, capable of much more than simply calling predefined functions with fixed schemas. The core thesis is that by treating LLMs as sophisticated code-generation engines and embracing recursive creation, developers can unlock greater flexibility and power, moving beyond the "boring" limitations of current tool-calling paradigms.

This talk argues that most developer tool AI pivots fail because they incorrectly implement AI features. Instead of simply adding AI to existing workflows or trying to compete with large AI providers, successful products leverage their unique competitive advantages. By identifying what makes a product distinct and then exploring how AI can amplify that specific advantage, companies can create new categories and reinvent user experiences, leading to significant growth.

This talk critically examines the Model Context Protocol (MCP) ecosystem, arguing that despite initial excitement and the promise of standardizing AI agent interactions with services, significant challenges remain. The speaker contends that the current state of MCPs is fragmented and difficult to use, hindering the practical application of autonomous agents. The core thesis is that while the potential for AI agents is vast, the MCP infrastructure is not yet mature enough to fully realize this potential, necessitating further development and standardization.

This talk explores the Blender MCP, an open-source project that enables Large Language Models (LLMs) to interact with and control Blender, a complex 3D creation tool. The core thesis is that by leveraging the MCP protocol and Blender's scripting capabilities, LLMs can significantly lower the barrier to entry for 3D content creation, allowing users to generate intricate scenes and assets through simple text prompts. This approach democratizes creative tools and points towards a future where LLMs act as orchestrators across various creative software.

This talk explores how the Model Contest Protocol (MCP) can be used to stabilize AI agents and agent networks. The core idea is that by systematically evaluating agent behavior and providing feedback, agents can learn to improve their performance and consistency, especially when tackling complex problems. This approach aims to create more controllable, transparent, and self-correcting agent systems.

This workshop details the process of fine-tuning an AI agent that utilizes the Model Context Protocol (MCP) for tool access. It covers generating high-quality reasoning traces from agent interactions with tools, saving these multi-turn conversations, and using them to fine-tune a language model, specifically demonstrating with a Quen model. The goal is to improve the agent's performance by training it on its own successful interactions.

This talk introduces Model Context Protocol (MCP) as a standardized way for AI assistants to interface with various tools and services, aiming to bridge the gap between current AI capabilities and the desire for a universal assistant like Jarvis. It posits that the primary barrier to advanced AI assistants has been the difficulty of building numerous integrations, and MCP offers a solution by establishing a common protocol that any AI assistant can use to interact with any service provider.

This workshop explores the power and versatility of function calling in AI models, arguing that it is a fundamental capability for building advanced AI applications. The talk traces the evolution of language models from simple text completion to instruction following and finally to sophisticated tool use. It demonstrates how function calling enables AI to interact with external systems, fetch data, take actions, and manage complex workflows, forming the backbone of agentic behavior.

This talk argues that tool calling is a critical, often overlooked component of AI agent development, deserving more attention than the agents themselves. The speaker emphasizes that an agent's effectiveness is directly tied to the quality, reusability, and robustness of its tools. The presentation explores different approaches to tool integration, from traditional, explicit tool calling to more embedded methods, and advocates for architectural patterns that promote separation of concerns.