MCP Dev Summit Bengaluru 2026

Local MCP prototyping is magic on a laptop, but scaling to production often triggers "Agentic Sprawl." To handle complex agent loops at scale, enterprises need a centralized architecture for integration, identity, and governance. This keynote explores Google Cloud’s full-stack vision for internet-scale agents. We will unpack the shift toward stateless MCP transports to solve multi-round-trip routing bottlenecks, show how Apigee converts legacy APIs into zero-code MCP skills, and highlight how developer tools like Antigravity and the Agent Development Kit (ADK) push the boundaries of AI from the cloud to the device.

Goose is an open-source AI agent that can be extended through integrations, tools, and community-driven projects. In this talk, I'll share my journey working with Goose, explore how its capabilities can be extended through community-driven projects, highlight examples from the Goose ecosystem, and discuss the development of GooseBot as one approach to bringing AI agents closer to developer communities. Along the way, I'll cover lessons learned from building in the open and why extensibility is key to the future of open-source AI agents.

The Model Context Protocol (MCP) is now an LF project, and that's fantastic news for the open source ecosystem. Last year MCP servers went mainstream fast, linking up AI models with apps, data and systems. Whether you are managing it or not, hundreds of people are already using MCPs within your company. Unfortunately, many IT teams are discovering this adoption, not planning it.

This talk provides a quick intro to the MCP ecosystem, and presents a four-stage maturity model for MCP adoption, from tracking shadow MCP development to secure, enterprise-wide deployment. You'll learn where your organization actually is (most are Stage 1 or early Stage 2), what infrastructure you need for each stage, and how to build the process and policies to turn MCP from a risk into an enabling technology.

This model is based on patterns from real deployments and hundreds of engagements with engineers dealing with this right now. I'll touch on MCP development, security, management, operations and how to get these incredibly useful tools into the hands of more and more users within your company.

I spent the last year building agentic systems with MCP and MCP Gateway, and want to share what I learned — especially the things you only hit when you try to build for a real, regulated domain.

The build is a four-part system: a React portal, a LangGraph agent, Microsoft MCP Gateway as the front door, and a FastMCP server with 19 tools behind it. This talk walks through how the pieces fit together and the specific patterns that worked.

What I'll cover:

- How I structured MCP tools with Pydantic schemas, idempotency keys, and correlation IDs that travel through every layer
- Why my first three gateway deployments failed and how the mcp-session-id header fixed stateful tool routing through MCP Gateway
- A simple tool wrapper pattern that keeps sensitive data like SSN out of the LLM context while the agent still reasons about the workflow
- Why I made consent its own MCP tool with a signed receipt instead of bundling it into submit
- Three gaps I hit in MCP and the gateway and how I worked around them — honest notes for the community

If you're building with MCP and MCP Gateway and heading toward anything production-grade, these are the patterns I wish I'd had going in.

MCP Apps are reshaping what a Model Context Protocol server can do — turning text-only tool exchanges into rich, interactive experiences embedded directly in the host. This session takes a builder's tour of the MCP Apps extension: core concepts, target use cases (dashboards, multi-step workflows, human-in-the-loop confirmations), the security model, and current limitations worth knowing before adoption.
A central theme is the visibility paradigm — letting UI carry state the model doesn't need to see, unlocking meaningful token savings on data-heavy flows. We'll cover iframe sandbox constraints, postMessage patterns, session-bound identity, and prompt-injection defenses for sensitive actions. We will also cover existing protocol limitations and work going on to address the same in exp-apps working group.
We close with a live Go-based demo executing a fund transfer flow end-to-end.

Over the last few months I've built and shipped 100+ agents in public, many wired into MCP servers running against local models through Ollama, LM Studio, and decentralized open-source inference. A draw.io MCP server driven by Llama 3.2, an Excalidraw MCP integration, a Bright Data MCP briefing agent, all running end-to-end without a single token leaving the host.

This talk is a working engineer's tour of that stack. We'll walk through a minimal local MCP setup (server + client + Ollama) and then dig into the real-world failure modes: tool-selection collapse on 7B models, JSON-schema compliance gaps, capability-negotiation mismatches, and the surprisingly large quality delta between structured-output fine-tunes and general chat models. I'll share the prompt shapes, tool-description patterns, and schema-validation tricks that reliably push small open models from "demo-grade" to "I'd ship this internally."

Attendees will leave with a reference architecture for private MCP, a shortlist of open models that actually handle tool calls well today, and a set of design patterns for MCP servers that degrade gracefully when the client LLM has 8B parameters instead of a trillion.

In 2013, shipping a Python service meant picking a base OS, writing an initscript, and fighting pip against the system package manager. Docker made it one command. Twelve years later, shipping an MCP server still feels pre-Docker — pick a language, spin up a process, hope the dependencies cooperate.

The WebAssembly Component Model quietly shipped the pieces it was missing in 2023. wasmcp, Microsoft Wassette, and Fermyon Spin now compose a single MCP server from Python tools that use pandas, TypeScript tools that use Zod, and Rust middleware that uses Regorus. One process. Hard isolation between components. One signed artifact, distributed through OCI registries, cold-starting in the low milliseconds.

This is a live-demo talk. I'll build a polyglot MCP server on stage, push it to a registry, and run the same bytes in four environments — a Kubernetes pod, a Spin function, a browser tab, and a Raspberry Pi. And I'll be honest about what WASM still can't do.

There's a running argument in the AI tooling world right now do you need MCP servers, or can you just use Skills? I've been on both sides of this. At Harness, I've built Claude Skills for DevOps workflows and worked with our MCP server that wraps the entire platform. And the honest answer is: it depends, but most people are picking the wrong one for the wrong job.

In this talk I'll break down where the boundary actually is. Skills are great when the knowledge is stable conventions, workflow logic, best practices. MCP servers earn their keep when you need live data, real-time API calls, or actions with side effects. The interesting part is what happens when you layer them: a Skill that knows how to debug a failed deployment, calling an MCP server that pulls live pipeline logs and execution data.

I'll walk through real examples I've built skills that started as simple "SKILL.md" files and grew into MCP-backed workflows, and cases where I over-engineered an MCP server when a markdown file would've done the job. If you're building agents and trying to figure out the right architecture, this talk should save you some wrong turns.

We All have been building AI Agents with MCP since it launched in 2024, but there's one thing no one is talking about - "What happens when MCP Fails? (and they fail often). MCP is just a process and it can crash, and so will the AI agent progress, it all can vanish with a crash.

Well, the new Tasks primitive in MCP (SEP-1686) helps a lot, it gives your AI agents a way to hand off long-running tools, but it doesn't solve the real problem. They don't maintain the state when the server crashes.

In this session, I'll do a live demo of a Kubernetes Auto Healing AI Agent with MCP server and walk through how to wrap MCP tool logic in workflows that survive crashes, restarts, and network failures.
I'll cover how to handle human-in-the-loop approvals inside long-running tools, how to retries and state-management, and how to observe what your MCP tools are doing in production.

I'll be breaking a running server on stage and show you the agent recovering without losing a step. Hence "The Invincible MCP Server"

AI Agents are getting smarter with each passing day. But, their interfaces? Not so much.

But, what if there is a way to turn the AI chat from a place where you converse into a place where you can actually work?

MCP Apps offer a solution to go beyond the text and standardize how MCP servers can deliver rich, bidirectional UI components like dashboards, forms, interactive visualizations & more. These components are rendered securely and natively within AI hosts, enabling agents to interact with users via rich interactive interfaces.

In this session, attendees will learn:
- Core architectural patterns from real MCP Apps development
- How to handle sandboxed host–server communication, manage state synchronization, stream real-time updates, handle async tasks, & add multiplayer collaboration
- How to leverage context and persist memory across conversations
- How to avoid some common pitfalls and utilize debugging workflows and tools
- How to add authentication & deploy a remote MCP Server providing MCP Apps

We will walk through a complete, production-style Sales Analytics MCP Apps and perform a code deep-dive to showcase the effective foundational patterns while building MCP Apps.

As MCPs mature, a gap emerges between benchmark performance and production behaviour:

1. Servers are tested in isolation, however in production they run alongside 100s of other servers, which affects tool selection. Typical evaluation frameworks are unable to reproduce this scale.
2. Single tool calls cannot test workflow compliance (the order and dependency of tool calls across multi step tasks).
3. Benchmarks are unable to measure user experience or quantify transcript quality.

This talk presents the design philosophy for robust MCP evaluation, grounded on field data and traffic analysis from 400+ production MCP servers.

We introduce a set of success metrics for MCP server authors and show how this re-order benchmark leaderboards, why servers that top toy evals regress in production, and what server authors should measure before shipping.

Attendees leave with a framework they can apply directly, data to benchmark against, and a clearer view of how they can adopt MCP confidently at scale for enterprise and internal usecases.

As enterprises adopt MCP to connect agents with internal tools, data sources, and business workflows, a new set of architectural challenges is emerging. 
As organizations adopt MCP and AI agents, many encounter the same challenges: exposing too many tools, poorly designed interfaces, excessive context sharing, weak security boundaries, limited observability, unreliable agent behavior, and lack of governance. These issues often remain hidden during development but become critical in production.
In this session, we'll explore common anti-patterns teams make while building agentic systems for the enterprise and the lessons learned from APIs, distributed systems, and cloud-native platforms. Attendees will learn practical strategies for designing secure, scalable, observable, and maintainable agentic systems that move beyond demos and stand up to real-world enterprise requirements.