MCP Dev Summit North America

Over the 2025 holiday break, I built MARVIN, an AI assistant that connects to my email, calendar, Jira, Confluence, and meeting notes through MCP servers. The most surprising lessons came from teaching a non-technical friend in marketing to use it. Within a day, she took a task that typically required 4+ hours and completed it in 30 minutes.

In this talk, I'll share practical insights from building and deploying MCP-powered agents in real workflows:

- Architecture decisions: How I structured MCP servers for Gmail, Google Calendar, Jira, and other integrations, and where I got it wrong
- The "junior intern" pattern: Why treating AI agents like trainable assistants drives real usage
- The naming problem: Why "MCP" is a terrible name for mainstream adoption and what we should call it instead
- Curiosity over mandates: Why top-down AI adoption fails, and what ground-up adoption looks like

I'll walk through 25 minutes of hard-won lessons from building something real, watching people use it, and iterating based on what actually worked.

Most MCP integrations power chat: an agent responds to a prompt. But MCP can power continuous loops — agents that run on schedule, find issues, and ship fixes without human prompting.

This talk covers how to build MCP servers for autonomous operations. The core pattern: Detect → Analyze → Propose → Execute → Report. Each loop queries MCP resources, processes data, and takes action based on its trust level.

I'll show three examples from e-commerce: (1) a learnings database — optimization patterns exposed as MCP resources that agents query to diagnose codebases; (2) CDN observability — requests, bandwidth, cache rates as queryable resources for finding performance issues; (3) conversion analytics — pageview and conversion data that agents correlate to propose content changes.

The key design question: when can agents act autonomously vs. require human approval? I'll present a trust framework where loops graduate from report-only → PR with review → auto-merge based on accuracy over time.

Takeaways: how to structure domain expertise as MCP resources, architecture for connecting observability to agents, and patterns for safe autonomous execution.

Creative assembly tasks - where agents compose pieces into coherent wholes - present unique challenges: tracking progress across turns, validating outputs, and recovering when something doesn't fit. This talk shares patterns for multi-turn workflows, illustrated through avatar generation where an agent assembles clothing into cohesive outfits.
Pattern 1: Session Memory - Track selections, failed searches, and partial progress across turns. Know what's in the cart before suggesting more.
Pattern 2: Composite Tools - Combine operations (search + fetch thumbnails) into single tools that reduce round-trips and give agents richer context.
Pattern 3: Pre-flight Validation - Check compatibility before expensive operations. Catch conflicts early (clashing items, missing pieces) rather than failing at generation.
Pattern 4: Validate-and-Retry Loops - Use VLM scoring on outputs, track best-of-N attempts, and guide agents toward improvements when quality falls short.
Avatar generation makes these patterns concrete - "getting dressed" is intuitive - but they apply broadly to document assembly, configuration builders, and any workflow composing parts into wholes.

MCP Apps open a new world of possibilities for interactions in AI chats.
While SEP-1865 defines how they work, this talk is about how to build them well.

We'll share the patterns emerging from real MCP Apps development: understanding the data flow between servers, apps, and models — including the interplay of tool inputs and results (streamed or complete), when to use structuredContent versus _meta, how model context updates propagate, how to create tools visible to your app only, etc.

Beyond the protocol mechanics, we'll cover practical concerns: building apps that work across hosts, handling authenticated data at scale, managing state persistence, and keeping heavy visualizations performant. We'll also walk through the common pitfalls — the silent failures and subtle bugs that waste hours — and the debugging workflows and tools that surface them.

You'll leave with tricks and patterns you can apply immediately and a mental model for reasoning about MCP Apps architecture.

MCPs unlock agent data access, but that's only the first step towards building agents that can work autonomously. How do we build a complete system where multiple agents work together, maintain state across sessions, and the whole thing runs reliably every day.

I use agents that work with 10+ connections daily for both personal and work use cases: health MCPs/APIs (Strava, Apple Health), productivity tools (Calendar, Linear), business systems (Attio CRM, email), and developer tools (GitHub). This talk shares effective architectural patterns that emerged from actually using this system.

We'll cover MCP composition (Virtual MCPs) and how to orchestrate multiple agents with memory. We show how state management using Git as agent memory is effective, as it provides versioning and rollback. We treat CLAUDE.md files as behavioral memory in the same system. Finally, we cover security concerns and best practices to manage agents that have access to sensitive and/or untrusted data.

Tool sprawl is a common failure mode for enterprise agents: the more tools an agent can reach, the less predictable it becomes—driving hallucinations, higher token costs, and larger security blast radius. Scaling agents safely requires specialization enforced by capability boundaries, not just better prompts.

This talk explores MCP best practices through a managed implementation where MCP servers are declared as explicit collections of tools and treated as governed objects. Specialization comes from two independent boundaries: (1) the MCP server definition limits the tool surface an agent can even access, and (2) RBAC still applies inside that server—so a user can only invoke tools they’re authorized to use, even if they can access the server that contains them.

Together, these boundaries reduce sprawl while improving operability: agents become easier to reason about, costs drop because fewer tools are in play, and least privilege is enforced with practical, role-aligned granularity.

MCP is a strong foundation for building AI agents, enabling fast iteration, clear boundaries, and safer early deployments. But as agents move from prototypes to products customers rely on, product teams begin to hit limits around reliability, user experience, observability, and long-running workflows.

In this talk, I’ll share a product leader’s perspective on how MCP-based agent systems evolve in production. We’ll explore the product signals that indicate when MCP-only approaches start to constrain outcomes, and how teams can extend MCP-driven systems to meet higher expectations around trust, clarity, and control. Attendees will leave with a practical framework for scaling MCP-based agents from experimentation to dependable products.

Everyone in this room is building MCP integrations. Almost nobody knows how well they're delivering value.
Outcomes are inherently non-deterministic: the same user request can produce completely different results depending on how the agent interprets user intent. Building an effective MCP server isn't just about handling tool calls, it's about spinning a data flywheel where every interaction teaches you what's working, what's failing, and what your users actually need.

The teams that figure this out compound user value over time. MCP has an XY problem. Almost everyone at this summit is focused on the Y. Let's talk about the X.

Model Context Protocol (MCP) enables standardized AI agents, but real adoption depends on how MCP servers operate in production—not just how the protocol is defined.

This session provides a high-level, practitioner perspective on running MCP in enterprise environments. It covers how MCP servers fit into existing platforms, with a focus on observability, security, distributed tracking of agent behavior, and resiliency. Rather than diving deep into implementation details, the talk shares lessons learned from real deployments and common pitfalls teams face when moving MCP from experimentation to production.