A virtual MCP Community Event for AI Builders

Kick off this virtual MCP Community Event for AI Builders with a welcome from the hosts. We'll introduce the event, walk through the agenda, and set the stage for a day of technical talks, live demos, and community discussions exploring the latest developments in the Model Context Protocol.

Over the past year, we've worked with dozens of enterprise teams deploying MCP into production. While every environment is different, many of the same operational challenges showed up again and again.

We'll share the patterns we kept seeing across deployments: where teams got stuck, what architectural decisions aged well, what broke as adoption expanded, and the practices that consistently made deployments easier to operate.

We’ll walk through what we’ve learned about authentication, agent identity, tool management, observability, policy enforcement, and running MCP at enterprise scale. Instead of focusing on just one deployment, we’ll share the patterns we kept seeing across many real-world environments.

The 728 spec is the largest change to MCP: the session handshake is gone, servers become formal OAuth 2.1 resource servers, extensions become first-class, and features like Sampling and Roots are deprecated. These changes start a 12-month migration clock. They also force strategic and tactical shifts. For example, how you re-architect auth is a tactical call everyone has to get right, and whether you run both versions or put a runtime in front is the strategic one that shapes the rest

AI agents powered by the Model Context Protocol (MCP) can now read emails, update CRMs, execute code, move money, and trigger business workflows autonomously. This raises a critical question: who is accountable when an agent acts? This session goes beyond capability and into governance exploring how organizations can deploy agentic AI responsibly without sacrificing the speed and autonomy that makes it valuable. Through real-world case studies in finance, healthcare, legal, and enterprise IT, attendees will walk away with a practical framework for scoped permissions, human-in-the-loop design, audit trails, and policy guardrails for MCP-connected agents

Most MCP security work assumes the threat lives at runtime, like a malicious prompt, a compromised model. But the vulnerabilities are already sitting in server source code, shipped to npm, waiting.

I audited 100 of the most-installed TypeScript MCP servers at the AST level and found 445 real findings across 70 servers which carried at least one exploitable pattern: command injection from tool input, path traversal, SSRF, and tool-poisoning through dynamically assembled descriptions, the class no prompt filter catches.

This talk shows what those patterns look like in real shipped servers, why they survive review, and why LLM-based scanners miss them. I demo MCPeek, the open-source ts-morph scanner I built to find them: multi-pass taint tracking from tool inputs to dangerous sinks, mapped to the OWASP MCP Top 10, emitting SARIF into GitHub Code Scanning. Fully offline, no model, no cloud, no per-scan cost.

I'll also be honest about what static analysis cannot catch and where dynamic and runtime approaches genuinely win.

Link to MCPeek: https://github.com/iamakash-06/MCPeek NPM Package: https://www.npmjs.com/package/mcpeek

Platform engineering faces a classic "Chicken Egg Problem" : platforms need adoption to become mature, but adoption requires onboarding that developers resist when deadlines are tight. We faced this exact hurdle with an Internal Developer Platform (IDP) serving over 4,000 monthly active users. Instead of forcing users to orchestrate between disconnected agents , we solved this by meeting developers where they already are. Using a "Bring Your Own Agent" strategy , we brought the IDP directly into the IDE. However, building a composable agent framework to support this revealed some hard truths. Relying on a flat agent mesh does not scale; it simply leads to "hallucinations snowballing". Furthermore, there is a hidden gap that nobody warns about: "Where MCP Ends A2A begins". Most agent failures don't happen inside protocols; they happen between them. In this session, we will unpack how to solve common agent loop development problems for dev teams. We will explore a robust Master Agent architecture and share a practical blueprint for maintaining "Agentic Context Hygiene".

We use MCP servers in production everyday. But how are we using them with a complex observability stack?

I'm my talk, I present not one but 2 MCP servers, which collaborate to provide accurate information for any practicioner working or deploying in production. I showcase with live demos, how to operate with cloud deployments, find out information on logs and metrics and then detect anomalies in the Observability.

How efficient can an engineer get with their troubleshooting? How much can we reduce alert fatigue in this setup?

Find out more in my talk and gain practical knowledge in building this setup one step at a time.

Long-running work - batch jobs, multi-step agent tasks, anything that takes minutes instead of milliseconds — doesn't fit a synchronous request/response model.

This talk covers how the Model Context Protocol solves that with Tasks: why it exists, how it works, and what changed in the 2026-07-28 update. Includes a live demo.

Cornelia Davis will share practical insights and perspectives on building with MCP.

A brief wrap-up of the event, key takeaways, and what's next for the MCP community.