MCP Dev Summit Notes

10 - AWS Team (Nicholas Aldridge & Tim Lim) - "Cloud-Scale MCP".md

AWS Team (Nicholas Aldridge & Tim Lim) - "Cloud-Scale MCP"

Speakers

Nicholas Aldridge - Principal Engineer, AWS (Inter-Agent Communication)
Tim Lim - Principal Developer Advocate, AWS (Cloud Deployment)

Key Points - Inter-Agent Communication (Nicholas)

Agent-to-Agent MCP Vision

• Flight booking scenario: User agent talks to airline agent automatically
• Behind-the-scenes agents: Tools that actually invoke other agents
• Complex workflows: Multi-agent coordination for sophisticated tasks
• Sequence diagrams: Real agent-to-agent handoff with status updates

Why MCP for Agents?

• Ease of integration: Same protocol for tools and agents
• Blurring boundaries: Tools becoming stateful/async, agents becoming specialized
• Shared primitives: Transport, auth, streaming already solved
• Rich functionality: Sampling, cancellation, streaming available for agents

Async Communication Needs

• Current limitations: SSE requires persistent connections for long-running tasks
• Reliability challenges: Connection drops, deployment issues, operational complexity
• Client polling solution: Task ID system for status checking
• Event-driven architecture: Webhook notifications for task completion

Resource Sharing Evolution

• State-aware resources: Beyond "ready" - failed, updating, in-progress states
• GET operations: Direct resource access by URI
• Resource references: Pass around resource IDs instead of embedding data
• Task-based model: Resources represent work status and results

Capability Discovery

• Enhanced annotations: Streaming, stateful, synchronous capabilities
• Client decision-making: How to handle different tool types
• Scalability concerns: Avoid infinite annotation proliferation
• Rich metadata: Tools need better self-description

Key Points - Cloud Deployment (Tim)

AWS MCP Server Ecosystem

• GitHub repository: AWS-samples/mcp-server-examples
• Growing collection: Hourly updates with new community servers
• Documentation MCP: Internal AWS team built doc search server
• Public APIs integration: Convert existing APIs to MCP tools

Deployment Options

ECS Fargate for SSE

• Persistent connections: When you need long-lived SSE connections
• Container deployment: Package servers as Docker images
• Auto-scaling: Minutes to scale up/down
• Use case: Complex agents requiring persistent state

Lambda for Stream

11 - Bloomberg Team (Sambhav Kothari) - "Scaling AI at Enterprise Level".md

Bloomberg Team (Sambhav Kothari) - "Scaling AI at Enterprise Level"

Speaker

Sambhav Kothari - Engineering Manager, Head of AI Productivity, Bloomberg

Key Points

Bloomberg Scale Context

• 40+ years in finance: Trusted by global financial market leaders
• Massive data processing: 2.5M documents, 1.5B messages, 400B data points daily
• Enterprise workforce: 25,000 employees, 9,500+ engineers, 50+ AI researchers
• Production standards: Real-time financial intelligence, not demos

AI Journey Timeline

• 2009: Machine learning for news sentiment analysis
• 2020: Neural networks for content discovery
• 2022: GenAI infrastructure mindset ready
• 2024: Systematic enterprise AI scaling with MCP

The Productionization Problem

• Demo-to-production gap: Teams could build demos in days, production took weeks/months
• Complex stakeholder workflow: AI developers, software engineers, UI developers, managers, legal
• Biggest bottleneck: Transitioning from impressive demos to production-ready applications
• Manual handoffs: Each transition point created friction and delays

Protocol-Driven Solution

• Dependency inversion: Protocols enable organizational-scale configurability
• HTTP parallel: Like HTTP enabled the internet ecosystem
• OpenAI API success: Standardization made LLM swapping simple
• MCP adoption: Q3 2024 early adoption, aligned internal approach with open standard

MCP Integration Journey

• Q3 2024: First protocol prototype with internal infrastructure
• Q4 2024: MCP alignment and close collaboration with Anthropic
• Q1 2025: Remote server support matching Bloomberg's reality
• Present: Universal tool compatibility across client applications

Enterprise Architecture

• Multi-tenant design: Robust identity awareness across systems
• Middleware layer: Access control and observability out-of-the-box
• Canonical identity: User and workload identities never leave Bloomberg
• Background deployment: Rapid experimentation and agent versioning
• Development-to-production: Cheap and easy capability scaling

Scaling Impact

• Developer democratization: From handful of specialists to 9,000+ contributors
• Role clarity: AI engineers focus on agents, broader teams build tools
• Separation of concerns: Dramatically accelerated agent development
• Zero additional integration: Works with broader MCP ecosystem automatically

Technical Benefits

• Interoperable systems: Tools work across all Bloomberg applications
• Identity-aware middleware: Security and permissions handled centrally
• Proxy architecture: SSO authentication with request translation
• Backwards compatibility: Existing agent infrastructure continues working

Next-Level Challenges Identified

• Remote tool operation: Surface new complexities at enterprise scale
• Community collaboration: Want to work with MCP community on solutions
• Open source contribution: Bloomberg's commitment to ecosystem growth
• Enterprise MCP ecosystem: Just beginning the enterprise journey

Governance and Management

• Tool registry: Scalable discovery with metadata and usage patterns
• Access control: Enterprise-grade permissions and policy enforcement
• Observability: Full visibility into tool usage and performance
• Version management: Controlled rollout and deprecation processes

Cultural Transformation

• Mindset shift: From custom integrations to protocol-driven development
• Velocity increase: Weeks-to-days productionization timeline
• Capability scaling: Thousands of engineers can meaningfully contribute
• Standard practices: MCP as foundational enterprise technology

Quote

"Instead of a handful of specialists, over 9,000 engineers can now meaningfully contribute. The shift wasn't about lowering the bar for AI development, it was about defining clear and powerful roles for everyone."

12 - Josh Dzielak (Postman) - "MCP Server Generator".md

Josh Dzielak (Postman) - "MCP Server Generator"

Speaker

Josh Dzielak - Staff Engineer, Postman

Key Points

The Time Travel Agent Vision

• Science fiction inspiration: Building agents that can explore the past
• API-driven time travel: Using date-range APIs to query historical data
• Demo goal: "What was the world like on September 12th, 2024?"
• Multi-source integration: News, crypto prices, NASA images from specific dates

MCP Server Creation Options

Option 1: Off-the-shelf MCP servers

Pros:

• Lots of existing servers available
• Officially maintained quality
• Best practices and real-world learnings built-in
• Tool filtering and token limits handled

Cons:

• Need separate server for each API
• Must review all code for security
• Many unused tools per server
• Tool overload degrades LLM performance

Option 2: Build everything from scratch

Pros:

• Full control over functionality
• Perfect customization
• No untrusted code
• Exactly the tools you need

Cons:

• Significant time investment
• Ongoing maintenance burden
• Expertise required

Option 3: Generate use-case specific servers (Postman's solution)

Pros:

• Get exactly the tools you need, nothing more
• Best cost/performance ratio
• Easy to add/remove tools as needs evolve
• Generated code (not pre-written) for security
• Consistent architecture across projects

Postman MCP Server Generator

Shopping Cart Experience

• Web interface: Select API endpoints like adding items to cart
• Postman API network: Access to thousands of public APIs
• Targeted selection: Choose specific endpoints, not entire APIs
• One-click generation: Download complete MCP server

Demo Implementation

Selected APIs:

• CoinGecko: Historical Bitcoin/Ethereum prices
• New York Times: Article search with date ranges
• NASA: Astronomy picture of the day

Generated Output:

• Complete MCP server scaffolding
• Individual tool directories for each API
• Client functions and OpenAI-style tool definitions
• Ready-to-run Node.js application

Live Demo Highlights

• API selection: Visual interface for browsing Postman's API catalog
• Parameter validation: Ensures selected endpoints accept date parameters
• Code generation: Real-time MCP server creation via Tool Generation API
• Testing workflow: Built-in MCP client for server validation
• Client integration: Seamless connection to Cursor/VS Code

Performance Benefits

• Focused tool sets: Prevent LLM confusion with too many options
• Token optimization: Smaller context windows, lower costs
• Better accuracy: Models perform better with curated tool sets
• Faster responses: Less processing overhead

Technical Architecture

• Tool Generation API: Postman's public API for MCP server creation
• JavaScript generation: Client functions + tool definitions per endpoint
• Metadata preservation: API documentation embedded in tool descriptions
• Standard structure: Consistent MCP server patterns

Time Travel Agent Results

• Multi-source queries: Successfully combined news, crypto, and space data
• Date-specific context: Historical information from September 2024
• Conversational interface: Natural language queries about the past
• Rich responses: Images, articles, and data from target time period

Developer Experience

• No API expertise required: Visual selection process
• Instant deployment: Generated servers ready to use
• Extensible architecture: Easy to modify and enhance
• Security conscious: Generated code instead of pre-built servers

Quote

"The problem is these tools are in a namespace that is flat. The LM is given a list of tools and there's one namespace when you have objects. We need exactly the tools we want for our use case, nothing more."

13 - Solomon Hykes (Dagger) - "Composable Functions and MCP".md

Solomon Hykes (Dagger) - "Composable Functions and MCP"

Speaker

Solomon Hykes - Co-Founder, Dagger

Key Points

Dagger Architecture Foundation

• Container-native engine: Built from first principles for build workflows
• BuildKit evolution: Takes Docker's BuildKit beyond Dockerfile limitations
• Graph execution: Directed Acyclic Graph (DAG) for function composition
• Immutable snapshots: Every operation creates cached, referenceable state
• LLM-compatible design: Execution model matches how LLMs build context

The Composition Challenge

• Flat namespace problem: MCP tools exist in single flat namespace
• Object-oriented needs: Real workflows require object composition
• Container → method chaining: container.from("alpine").withFile("/hi", "hello")
• Reference-based: Functions return object IDs, not text output
• Auto-completion: Dynamic discovery of available methods per object type

Interactive Shell Demo

$ container
# Returns: Container ID (not text output)
$ container from alpine
# Chained operation, cached result
$ container from alpine with-file /hi "hello"
# Each step builds on previous, immutable snapshots

Sandboxing Benefits

• Ephemeral containers: Clean slate for each session
• Namespace isolation: No pollution of shared system resources
• Parallel safety: 100 concurrent sessions without conflicts
• Automatic cleanup: Containers disappear when session ends
• Production-ready: No Docker daemon pollution or resource leaks

LLM Integration Success

• Prompt mode: Switch from shell to LLM interaction
• Automatic tool exposure: All Dagger functions become MCP tools
• Complex orchestration: LLMs can handle sophisticated build workflows
• Full tracing: Every operation logged and browsable
• Context building: Immutable steps match LLM context patterns

MCP Mapping Challenges

• 3D to 2D problem: Object-oriented API flattened to tool list
• Namespace explosion: Methods exposed as container_from, container_with_file
• Context management: LLMs must track object relationships
• Smart models help: GPT-4/Claude can navigate complex object graphs
• Worth the complexity: Enables sophisticated multi-step workflows

Community Adoption

• Discord experimentation: Open source community testing agent workflows
• CI/CD integration: Sneaking agents into traditional build pipelines
• Function composition: Deterministic + non-deterministic steps mixed
• Goose integration: Works with external MCP clients seamlessly

Technical Architecture

• SDK ecosystem: TypeScript, Python, Go implementations
• Remote execution: Engine runs anywhere, clients connect over network
• BuildKit foundation: Proven container orchestration technology
• Caching layer: Content-addressable storage for all operations
• Network transport: Same session accessible from multiple clients

Tracing and Observability

• Full execution logs: Every container operation recorded
• Latency tracking: Precise timing for each step
• Cache hit analysis: Visual indication of cached vs fresh operations
• Debugging support: Step-by-step workflow examination
• Production visibility: Real CI/CD workflows alongside agent experiments

Future Vision

• Agent-driven DevOps: Sophisticated build/test/deploy workflows via conversation
• Composable infrastructure: Mix human-written and agent-generated operations
• Educational potential: "You should pivot to be an MCP framework"
• Universal sandboxing: Safe execution environment for any agent task

Quote

"This is basically an execution engine that works the way LLMs work. You're building the LLM context one message at a time, and the LLM context is immutable. You're just adding stuff to it."

14 (LlamaIndex) - "Protocol Landscape Analysis".md

(LlamaIndex) - "Protocol Landscape Analysis"

Key Points

The Crowded Protocol Landscape

A-Star Protocols (All start with 'A')

• A2A (Agent-to-Agent): Focus on long-running, async agent communication
• ACP Connect: Cisco's protocol with agent hosting and launching
• ACP Communication: IBM's fork of MCP, diverging toward A2A functionality
• Agora: Natural language protocol that upgrades itself
• ELMAS: Eclipse Foundation (IBM) protocol, very similar to others

Key Differentiators

• HOA (A2A): Built for async, multi-day agent interactions
• Agora uniqueness: Starts as natural language, self-upgrades to formal protocols
• ACP Connect: First-class agent distribution and execution
• Most others: Solving nearly identical problems with slight variations

MCP's Competitive Advantages

Adoption Leadership

• Real traction: Demonstrated utility in this room and beyond
• Network effects: Standards win through adoption, not features
• Attention economy: "Attention is all you need" - MCP has mindshare
• React parallel: Small, focused solution that conquered larger problem space

Technical Simplicity

• Constrained problem: Tool discovery and execution (not everything)
• Proven utility: Solved immediate developer needs effectively
• Expansion potential: Can grow into larger problem spaces with traction
• Standards adoption pattern: Focus → traction → expansion

Protocol Convergence Problem

• Massive duplication: All protocols solve 90% identical problems
• Integration complexity: Adding new protocols increases system complexity
• MCP sufficiency: Current MCP may handle inter-agent needs adequately
• Network effects: Winner-take-all dynamics in protocol adoption

Missing Infrastructure (All Protocols)

Universal Registry

• Discovery limitation: Must know server exists before querying
• Search impossibility: No way to find servers for specific tasks
• Federation need: Central registry with distributed capabilities
• Critical scaling requirement: Essential for global agent ecosystem

Authorization Framework

• Beyond authentication: How to get permission to use someone else's servers
• Decentralized challenge: Permissionless system needs permission controls
• Payment integration: Using others' compute resources requires compensation
• Blockchain consideration: Distribution and payment coordination (not first priority)

Reputation System

• Agent proliferation: Many agents will advertise similar capabilities
• Quality differentiation: How to identify reliable vs unreliable agents
• Security imperative: Prevent malicious tool masquerading
• Network safety: Essential for discoverable agent ecosystem

Technical Assessment

What MCP Lacks vs A-Star Protocols

• Almost nothing: MCP has discovery, authentication, tools, resources
• Async improvements: Being addressed with streamable HTTP
• OAuth integration: Authorization layer in development
• Protocol negotiation: Only Agora's self-upgrading capability missing

What MCP Has That Others Don't

• Real adoption: Actual usage vs theoretical protocols
• Ecosystem momentum: Tools, clients, servers being built daily
• Community energy: Active development and contribution
• Proven patterns: Working solutions for real problems

Future Recommendations

• MCP sufficiency: Current protocol likely adequate for inter-agent communication
• Registry priority: Universal discovery system most critical missing piece
• Authorization development: OAuth integration crucial for enterprise
• Reputation systems: Safety infrastructure for agent ecosystem
• Community focus: Solve adoption problems, not create new protocols

Quote

"MCP is highly duplicative of all of these other protocols. Adding another protocol to the mix seems to add complexity for minimal gain, while adding inter-agent features to MCP seems like a relatively small lift."

15 - Registry Team (Pattis, Toby, Alex) - "Official MCP Registry".md

Registry Team (Pattis, Toby, Alex) - "Official MCP Registry"

Speakers

Pattis - Founder, PulseMCP
Toby Padilla - Principal Product Manager, GitHub
Alex Hancock - Software Engineer, AI Agent, Block

Key Points

Problem Statement - Registry Fragmentation

Third-Party Registry Limitations

• Incomplete coverage: Web scrapers miss GitLab, Bitbucket, complex repos
• Simple detection: Only find single-server repos, miss nested projects
• Remote server gap: Closed-source hosted servers not discoverable
• Fragmented data: No comprehensive view of available servers

Server Maintainer Burden

• Multiple registrations: Must update every registry manually
• Account requirements: Sign up for each registry service
• Update complexity: Separate maintenance for each listing
• Email-based updates: Manual processes for registry inclusion

Client Installation Complexity

• README parsing: Clients must interpret installation instructions
• JSON configuration: Users copy-paste complex configuration
• No standardization: Every server has different setup process
• Error-prone setup: Manual configuration leads to mistakes

Solution Architecture

Server.json Standard

Four core components:

1. Basic metadata: Name, description, functionality overview
2. Source references: Links to code repositories and documentation
3. Remote URLs: Hosted server endpoints (optional)
4. Installation instructions: Structured, machine-readable setup steps

CLI Publishing Tool

• npm-like workflow: mcp publish command for server registration
• Authentication: Secure server identity verification
• Automated updates: Version control and change management
• Reverse DNS naming: GitHub-style server identification

ETL Layer Architecture

• Client abstraction: MCP clients don't query registry directly
• Custom enrichment: Add proprietary data (download counts, ratings)
• Search optimization: Tailored filtering and ranking per client
• Federation support: Multiple registries can share API shapes

Live Demo Success

• GitHub MCP server: Published reverse-DNS identified server
• OAuth authentication: Secure publishing with GitHub identity
• Multi-client support: Same server works in Goose and VS Code
• Automatic installation: Structured data enables one-click setup

In-Scope Solutions

• Comprehensive discovery: All MCP servers, regardless of hosting
• Unified publication: Single point for server registration
• Structured installation: Machine-readable setup instructions
• Source of truth: Canonical server information and metadata

Out-of-Scope Delegations

• Source code storage: Use existing npm, PyPI, container registries
• Advanced search: Delegate to client marketplaces and ETL layers
• Rich filtering: Let downstream consumers add specialized features
• Curation/ranking: Enable third-party services for specialized needs

Community Collaboration

• Open source development: GitHub-based community contribution
• Feedback collection: Are we capturing all necessary metadata?
• API standardization: Can third-party registries use same shapes?
• Federation planning: Enable registry composition and interoperability

Technical Implementation

• RESTful API: Standard HTTP-based registry interface
• Docker Compose: Local development and testing environment
• OAuth integration: Secure authentication for server publishing
• Version management: Handle server updates and deprecation

Ecosystem Benefits

• Reduced fragmentation: Single source of truth for server discovery
• Developer efficiency: One publication reaches all clients
• User experience: Consistent installation across all MCP servers
• Innovation enablement: Lower barriers to server creation and distribution

Future Roadmap

• Federation support: Multiple registries sharing compatible APIs
• Enterprise registries: Private server catalogs for organizations
• Advanced metadata: Richer server descriptions and capabilities
• Integration ecosystem: Enable third-party tools and services

Quote

"We expect there to be an ETL layer between the official registry API and the MCP client. MCP clients will most likely not query the registry directly on behalf of every user."

16 - MCP Middleware Discussion.md

MCP Middleware Discussion

Speaker

Anonymous Presenter - Software Engineer

Key Points

Middleware Definition & Need

• Horizontal infrastructure layer: Sits between MCP clients and servers
• Common functionality: Logging, authentication, rate limiting, transformations
• API platform parallel: Similar to how API gateways solve cross-cutting concerns
• Scaling necessity: Individual client implementations don't scale efficiently

Agent-Facing Features (Client ↔ Middleware)

Access Control & Security

• Granular permissions: Audio agents can't access certain tools for specific users
• Rate limiting: Prevent abuse and manage resource consumption
• Request validation: Schema checking and input sanitization
• DDoS protection: Shield servers from malicious traffic patterns

User Experience Enhancements

• Dynamic tool selection: Enable/disable tools based on user intent
• Context management: Smart tool filtering to preserve context space
• User preferences: Binary choices (execute shell commands) → nuanced controls
• Batching: Optimize background agent workflows

Server-Facing Features (Middleware ↔ Server)

Error Handling & Reliability

• Response normalization: Standardize error formats across different servers
• Retry logic: Intelligent retry patterns with exponential backoff
• Circuit breaking: Protect against failing server dependencies
• Workflow orchestration: Long-running transaction support

Content Transformation

• UI generation: Convert API responses to renderable formats
• Error translation: Transform technical errors into user-friendly messages
• Data enrichment: Add metadata or context to server responses
• Format conversion: Handle different data formats between client expectations and server output

Real-World Example - Credit Card Error

Problem: UI generation service returns technical error

• "If you're human, add credit card to authenticate"
• "If you're an agent, tell your human to add credit card"

Middleware Solution:

• Detect authentication errors
• Provide client with actionable resolution steps
• Abstract away server-specific error handling

Machine-Initiated Workloads

• Scale prediction: Machine workflows will exceed human-generated requests
• Autonomous operation: Agents running 24/7 without human intervention
• Resource optimization: Centralized management of tool discovery and caching
• Performance requirements: Lower latency and higher throughput needs

Why MCP Middleware Now?

• Protocol maturity: MCP stable enough to build infrastructure layers
• Ecosystem growth: Hundreds of developers, numerous applications, multiple business areas
• Complexity management: Individual implementations don't scale to enterprise needs
• Standardization opportunity: Create reusable patterns across organizations

Implementation Considerations

• Open source preference: Encourage community-driven middleware solutions
• Protocol transparency: Middleware should enhance, not obscure MCP semantics
• Performance impact: Minimize latency introduction while adding value
• Vendor neutrality: Avoid lock-in while enabling commercial offerings

Technical Architecture

• Proxy pattern: Transparent request/response interception
• Configuration driven: Declarative rules for transformations and policies
• Plugin system: Extensible architecture for custom functionality
• Observability: Rich logging, metrics, and tracing capabilities

Call to Action

• Community building: Encourage open source middleware development
• Use case sharing: Identify common patterns across organizations
• Standard development: Work toward middleware interoperability
• Commercial opportunities: Balance open source with sustainable business models

Quote

"When you have hundreds of developers building numerous applications across multiple business areas, you can't just hardcode dependencies, you need configurable swappables. Protocols enable dependency inversion, which is essential for scaling."

3 - Jerome Swannack (Anthropic) - "MCP Protocol Evolution.md

Jerome Swannack (Anthropic) - "MCP Protocol Evolution"

Speaker

Jerome Swannack - Member of Technical Staff, Anthropic

Key Points

Community Growth Achievement

• Explosive adoption: 10,000+ MCP servers created in just 6 months since launch
• Sold-out conference: From protocol launch to 300-person developer conference
• Bottom-up evangelism: Started spreading MCP through demos, tutorials, and community building
• Scaling challenge: Working to accommodate massive open source contributions

Technical Evolution - Streamable HTTP

• Transport revolution: New streamable HTTP replacing SSE for better scalability
• No persistent connections: Eliminates scaling challenges with long-lived connections
• Progressive enhancement: Servers only need additional features when required
• Bi-directional capability: Maintains full MCP interaction patterns without WebSocket complexity

New Protocol Features

Elicitation - Interactive Agent Communication

• Dynamic information requests: Servers can ask clients for additional information mid-execution
• JSON schema support: Structured way to describe needed information
• Enhanced user experience: Enables hotel booking agent to ask "which of these 3 hotels?"
• Just-in-time UI: Clients can render dynamic interfaces for user interaction

Structured Tool Results

• Beyond text responses: Tools can return structured data for client interpretation
• Context window optimization: Allows filtering and processing before adding to context
• Dashboard generation: Enable dynamic UI creation based on tool output
• Composable workflows: Better tool chaining and result processing

Development Ecosystem Initiatives

• MCP Inspector: Community-contributed tooling for server development and testing
• Remote MCP examples: Fully open source servers demonstrating complete feature sets
• Resource clients: Reference implementations for richer interaction patterns
• Registry progress: Discoverability and server management improvements

Governance Evolution

• Community-driven future: Planning transition from Anthropic to community governance
• Open decision-making: Balancing rapid innovation with inclusive processes
• External governance: Moving governing body outside Anthropic for true open source model
• Scaling challenges: Managing fast-paced development with community input

Technical Architecture Insights

• Server complexity principle: Prefer client complexity over server complexity for ecosystem health
• Fewer clients, many servers: Design decisions favor server developers
• Fragmentation avoidance: Universal transport methods maintain ecosystem compatibility

Quote

"We had a post launch and we were saying that went surprisingly well received. I think we're probably revised that. So like this is the same how much you're talking to a sold out conference six months after resources."

4 - Sean Smith (LM Studio) - "Resources in MCP".md

Sean Smith (LM Studio) - "Resources in MCP"

Speaker

Sean Smith - Principal, LMindset

Key Points

The Context Window Challenge

• Tool overload problem: Demonstrated 47% longer conversations with extra tools enabled
• Token consumption: Every tool description consumes valuable context space
• LLM confusion: Too many tools cause model performance degradation
• Solution needed: Dynamic tool selection and better context management

Resources vs Tools - Key Differences

• Semantic metadata: Resources provide information about data shape and structure
• Application control: Applications decide how to handle resource data
• Context efficiency: Resources can be processed before adding to context window
• URI schemes: Enable shared understanding between clients and servers

Advanced Resource Patterns

Dynamic Context Management

• Templated resources: Can be embedded in prompts for sophisticated workflows
• In-context learning: User/assistant pairs for better model training
• Conditional loading: Resources loaded based on user intent and context
• Update notifications: Servers can notify clients when resources change

Sampling Integration

• Content processing: Use sampling to condense large resources before context inclusion
• PDF summarization: Download paper, summarize via sampling, add condensed version to context
• Dynamic generation: Create prompts and resources on-the-fly using sampling

URI Schemes for Interoperability

• Shared semantics: Standard schemes enable client/server understanding
• Example implementation: If URI includes "ui", render HTML content inline
• Domain-specific applications: Home automation, document management, etc.
• SDK development: Reusable patterns for common resource types

Fast Agent Demo

• Practical implementation: Tool combining prompt server for easy experimentation
• In-context learning example: "Refactor this Go code following best practices"
• Resource embedding: Sample bad file → expected output → actual file to refactor
• Performance impact: Dramatically improves model performance on specific tasks

Future Improvements

• Spec enhancements: Minor tweaks needed to make resources easier to use
• MCP working group: Active collaboration on resource improvements
• Community participation: Encouraging developer feedback and contributions

Technical Architecture

• Composable design: Resources work alongside prompts and tools
• Metadata-driven: Rich semantic information enables intelligent client behavior
• Caching friendly: Immutable resources can be cached effectively
• Transport agnostic: Works with both SSE and new streamable HTTP

Quote

"Resources give us an extra level of semantics beyond just plain text content. We can use URI schemes to start to coordinate expectations between different parts to build much more sophisticated applications."

5 - Kent C. Dodds - "Building Jarvis: The Future Vision".md

Kent C. Dodds - "Building Jarvis: The Future Vision"

Speaker

Kent C. Dodds - Software Developer Educator, EpicAI.pro
🐦 Twitter: @kentcdodds

Key Points

The Jarvis Vision

• Iron Man inspiration: Tony Stark's AI assistant as the gold standard
• Complete automation: Personal assistant, system control, emergency response, engineering support
• Natural interaction: Voice, gestures, multimodal communication
• Proactive intelligence: Anticipates needs, provides status updates automatically
• Universal presence: Same assistant across all devices and contexts

Paradigm Shift Prediction

• Web evolution parallel: Browsers → Jarvis clients, Websites → MCP servers
• Universal context: One AI assistant with complete life context
• Dynamic augmentation: Load MCP servers based on current needs (workout, travel, therapy)
• Personal scaling: Single interface for all digital interactions

The Experience Requirements

• Natural language: Primary interaction method
• Immediate response: Even for long-running tasks, instant acknowledgment
• No configuration: Zero setup, automatic authentication management
• Context continuity: Remembers everything across sessions and devices
• Multimodal support: Voice, text, gestures, visual inputs

Current Problems to Solve

Client-Side Challenges

• Zero user configuration: No JSON files, automatic server discovery
• Tool selection intelligence: Automatic relevant tool loading
• Speaker distinction: Multiple users in conversation scenarios
• Modality switching: Seamless voice ↔ text ↔ visual transitions
• Proactive notifications: Background task completion alerts
• Conversation continuity: Context preservation across sessions

Server-Side Needs

• Quality server shortage: Need more high-quality MCP servers
• Authentication automation: OAuth flows handled transparently
• Background task support: Long-running, scheduled operations
• Memory and learning: Persistent context and user preferences
• Scope management: Servers should know their intended audience

Real-World Test Scenarios

Movie Planning Example

"I want to see the latest Mission Impossible movie in theaters with my friends Josh, Sean, Julie, Garrett and Andy. Saturday 31st in the evening is best. Find a theater showing Mission Impossible after 8pm, close to all of us. Get tickets for seats together, create calendar event and invite everyone. Let friends know how much they owe."

Required MCP servers: Contacts, movie theaters, location services, payments, calendar, SMS

Municipal Services

• Local government integration: Soccer field reservations, permit applications
• MCP democratization: Every city can participate without Big Tech integration
• Personalized coaching: AI coaches with memory and calendar integration

UI Requirements

• Beyond text: Rich visual interfaces when appropriate (maps, directions, dashboards)
• Contextual rendering: Different output formats based on task type
• Interactive elements: Not just read-only displays

Proactive Intelligence Examples

• Financial optimization: "You're paying $30/month for car washes but only go twice. Cancel or schedule more visits?"
• Behavioral insights: Pattern recognition and recommendation
• Anticipatory actions: Handle routine tasks without explicit requests

Current State Assessment

• Technology exists: All capabilities are technically possible today
• Integration gap: No current client handles the complete vision
• Ecosystem building: Need comprehensive MCP server coverage

Educational Mission

• Epic AI Pro: Teaching platform for building quality MCP servers
• Community building: Training developers to create the Jarvis ecosystem
• Practical focus: Real-world implementations over theoretical discussions

Quote

"I want us to build Jarvis and I think that we can do it with MCP. The technology is there. We can give Jarvis hands through MCP servers."

6 - Block Team (Angie Jones) - "Scaling MCP Across 12,000 Employees".md

Block Team (Angie Jones) - "Scaling MCP Across 12,000 Employees"

Speaker

Angie Jones - VP Developer Relations, Block

Key Points

Explosive Internal Adoption

• Developer success: 75% of engineers saved 8-10 hours/week within first month
• Organic growth: Adoption doubled without formal rollout campaign
• Weekly engagement: 50% increase as more use cases emerged
• Cross-functional demand: Non-engineering teams wanted access after seeing results

Enterprise Rollout Strategy

Infrastructure Decisions That Worked

• Desktop app: Beyond CLI, enabled non-technical users
• LLM agnostic: Multiple model providers (OpenAI, Anthropic, Meta) via Databricks
• Model flexibility: Different teams prefer different models for different tasks
• Automatic deployment: Goose added to managed software center with auto-updates

Scaling Challenges & Solutions

60+ Internal MCP Servers

• Security-first approach: All servers built internally, even if open source versions exist
• Hack week catalyst: Used internal hackathon to rapidly build server library
• Full control benefits: Authentication, versioning, and feature management
• Allowlist system: Blocks external servers not on approved list

Context Window Management

• Dynamic server enabling: Only loads relevant servers based on user intent
• Automatic summarization: Conversations summarized when approaching context limits
• Context progress bar: Visual indicator of remaining context space
• Smart tool selection: Example - Asana task + calendar event only enables those 2 servers

Authentication Revolution

• OAuth with SSO: Integrated with enterprise identity provider
• Zero API key management: Short-lived credentials, automatic token refresh
• Familiar login flow: Standard enterprise SSO experience
• Security & traceability: Full audit trail without user friction

Real-World Impact Examples

Data Analysis Breakthroughs

• Snowflake integration: Natural language queries instead of SQL
• Fraud detection: Employee spotted suspicious transaction patterns
• Sales optimization: 81,000 leads analyzed and distributed across programs in 1 hour
• Time savings: "This was so helpful I could cry" - actual user quote

DevOps Intelligence

• PagerDuty analysis: Beyond firefighting to pattern recognition
• Root cause identification: Uncovered recurring issues causing alerts
• Proactive fixes: Bird's eye view enabled preventive actions
• Incident reduction: Eliminated repeated alerts through systematic analysis

User Experience Innovations

• Recipe sharing: Package MCP servers + goals into reusable mini-agents
• One-click deployment: Static web apps deployed directly from conversations
• Enterprise search: Glean integration for institutional knowledge access
• Workflow automation: Complex multi-step processes automated conversationally

Community & Education

• Slack channels: Dedicated spaces for questions, inspiration, and feature requests
• Brown bag sessions: Weekly workshops from prompting basics to MCP server building
• Office hours: Regular developer support and consultation
• Team workshops: Custom sessions for specific department needs

Cultural Impact

• Non-technical creativity: Marketing, sales, legal teams more creative than engineers
• Inspiration sharing: Employees showcase time-saving automations
• Knowledge democratization: Complex tasks accessible to all skill levels
• Productivity culture: Organization-wide efficiency mindset

Technical Architecture

• Managed infrastructure: Centralized deployment and management
• Multi-tenant support: Isolation and personalization per user
• Integration depth: Native connections to all major internal tools
• Scalability planning: Architecture handles company-wide usage

Quote

"This isn't just a side project for us anymore. It's not an indie experiment. MCP and agents at scale are shaping how we think about enterprise companies."

7 - PayPal Team - "Agentic Commerce".md

PayPal Team - "Agentic Commerce"

Speakers

Brendan Lane - Sr. Dir. Developer Product, PayPal
Nitin Sharma - Principal MTS, AI Research, PayPal

Key Points

Agentic Commerce Vision

• End-to-end automation: Agent handles search, comparison, purchase, and tracking
• Conversational shopping: Natural language replaces traditional e-commerce UX
• Merchant benefits: Automated customer service, sales optimization, inventory management
• Multi-factor authentication: Maintains security standards throughout process

Live Demo Highlights

• Product discovery: "Find me a white hoodie" → agent searches catalog
• Detailed analysis: Agent retrieves pricing, sizes, stock availability
• Purchase flow: Initiates cart, handles payment method selection
• MFA integration: Secure authentication via PayPal app confirmation
• Order completion: Real confirmation emails, just like traditional checkout

Enterprise Design Principles

Tool Ownership & Scope

• Central registry: Tools discoverable by ID with clear ownership
• Access controls: Granular permissions per agent and environment
• Unique identity: Namespaced tools with proper versioning
• Schema contracts: Explicit input/output typing and documentation
• Policy guardrails: Rate limits, timeout rules, retry policies

Functional Behavior

• Modularity first: Each tool does exactly one thing (single responsibility)
• Explicit dependencies: Tools declare required context upfront
• Structured error handling: Defined recovery logic and retry patterns
• Latency transparency: Tools advertise expected execution time
• Composability support: Multi-step and multi-agent workflow support

Lifecycle Management

• Usage monitoring: Track invocations, agents, and performance metrics
• Integration validation: Schema validation and compliance testing before promotion
• Maturity tracking: Tool stability and readiness indicators
• Deprecation flow: Replacement tools and automatic sunset handling
• Change history: Full audit trail with rollback capabilities

Security Architecture

Secure Envelope Design

• Context scoping: Only share necessary fields, expire appropriately
• Encryption in transit: HTTPS with HMAC/JWT signatures
• Replay protection: Nonce implementation and request expiration
• Agent identity: Verified agent authentication and authorization
• PII protection: Field-level encryption for sensitive data

Enterprise Integration

• Beyond MCP: Works with A2A protocols for agent discovery
• Broker architecture: Central registry for agent capabilities
• Token exchange: Seamless authentication between agents
• Workflow orchestration: Multi-agent task coordination

Real-World Applications

• Customer tools: Catalog search, product details, checkout, order tracking
• Merchant tools: Sales reporting, inventory queries, customer insights
• Financial tools: Transaction processing, fraud detection, compliance reporting
• Analytics tools: Performance metrics, trend analysis, revenue optimization

Technical Implementation

• MCP server architecture: Modular design with clear separation of concerns
• Authentication layers: OAuth integration with enterprise identity
• Context management: Minimal data sharing with proper scoping
• Error resilience: Comprehensive error handling and recovery

Future Integrations

• A2A Protocol: Agent-to-agent communication for complex workflows
• Registry services: Universal tool discovery and capability matching
• Privacy preservation: Advanced field scoping and context protection
• Event-driven flows: Asynchronous task execution and notifications

Quote

"We really built the tools in a way that they're composable - you can use them all together or you can use them individually. This gives you a lot of different micro options for what control you can enable integration to have."

8 - Microsoft Team (Den Delimarsky) - "C# SDK with Authorization".md

Microsoft Team (Den Delimarsky) - "C# SDK with Authorization"

Speaker

Den Delimarsky - Principal Product Manager, Microsoft

Key Points

Developer Experience Philosophy

• Plug-and-play simplicity: Developers shouldn't need to be security experts
• Idiomatic C# design: Familiar patterns for .NET developers
• Ecosystem compatibility: Deploy to Azure or any .NET-based provider
• Future-proof architecture: Extensible for new authorization methods

OAuth 2.1 Integration

• Modern standards: Uses OAuth 2.1 best practices, not legacy OAuth 2.0
• Separation of concerns: OAuth authorization server separate from MCP resource server
• Protected resource metadata: Automatic 401 handling with authorization server discovery
• Dynamic client registration: Clients register automatically without pre-configuration

C# SDK Implementation

Server Setup (Minimal Code)

builder.Services.AddAuthentication()
    .AddJwtBearer("MCP", options => {
        // Token validation configuration
    });

builder.Services.AddMCP()
    .WithResourceDefinition("weather-server")
    .WithSupportedBearerMethods("header")
    .WithSupportedScopes("weather:read");

Client Implementation

• Built-in credential provider: ISPCredentialProvider interface
• Automatic token handling: Refresh, validation, and error recovery
• Browser integration: Automatic OAuth flow with browser popup
• VS Code compatibility: Works with VS Code's new authorization support

Live Demo Success

• Local MCP server: Weather server running on localhost:7071
• Authentication flow: Azure AD integration with automatic browser redirect
• VS Code integration: Seamless connection with enterprise SSO
• Tool execution: Successful weather API calls with proper authorization

Enterprise Benefits

• Zero security expertise required: SDK handles all OAuth complexity
• Enterprise identity: Works with Azure AD, but not Microsoft-specific
• Automatic token management: Refresh, validation, expiration handling
• Familiar deployment: Standard ASP.NET Core patterns

Technical Architecture

• Bearer token validation: JWT token validation with proper audience checking
• Middleware integration: Standard ASP.NET Core authentication pipeline
• Error handling: Proper 401 responses with metadata for client discovery
• Extensible design: Support for future authorization methods

VS Code Integration

• Authorization support: New MCP authorization spec support
• Automatic discovery: Client reads protected resource metadata
• SSO compatibility: Works with existing enterprise authentication
• Developer workflow: Seamless integration with existing development tools

Quote

"We do not want to expect every single developer that uses MCP to have to learn OAuth, read a bunch of RFCs and start implementing their own thing from scratch. That's just way too much work."

9 - Cloudflare Team (Dina Kozlov) - "Stateful MCP Servers".md

Cloudflare Team (Dina Kozlov) - "Stateful MCP Servers" Speaker Dina Kozlov - Sr. Product Manager, Cloudflare

Key Points The Context Problem Context loss: Progress lost when switching MCP clients or starting new sessions Personal assistant analogy: Context should live with the server, not just the client User personalization: Preferences and history should persist across interactions Cross-client continuity: Same context available in Claude, Cursor, or custom agents Durable Objects Architecture Agent per user: Each user gets their own isolated compute + storage agent Built-in memory: Database automatically associated with each user session Global distribution: Runs close to users and AI agents for minimal latency Automatic scaling: Handles load without manual infrastructure management Best Reads Demo (Book Recommendation Server) Personal preferences: "I like mystery novels" Reading history: "I just read The Mysterious Tom Ridley" Contextual recommendations: Uses both preferences and history Cross-client persistence: Same recommendations available in different MCP clients Authentication layer: OAuth integration for multi-user support 30-Second Deployment Template-based: GitHub examples with complete boilerplate One-click deploy: Deploy to Cloudflare button Multiple languages: Python and JavaScript templates available Built-in features: Authentication, storage, and global distribution included Technical Implementation Code Example - Storing User Preferences javascript // Store user preference setFavoriteGenre(genre) { this.state.set('genres', [...existingGenres, genre]); }

// Retrieve for personalized recommendations getRecommendations() { const userGenres = this.state.get('genres'); const readBooks = this.state.get('readBooks'); // Build personalized prompt using user context } Remote MCP Benefits Streamable HTTP: Built-in support for new transport method Server-sent events: Automatic fallback for older clients No transport code: Developer focuses on business logic, not protocol details Enterprise Use Case - Cloudflare Code Execution Secure sandboxes: Isolated environments for code testing Persistent sessions: Same environment across different MCP clients Context preservation: All interactions and state maintained Cross-client compatibility: Works from Cursor, VS Code, or custom tools User Experience Benefits Seamless transitions: Switch between clients without losing progress Personalized interactions: Server learns user preferences over time Contextual intelligence: Recommendations improve with each interaction Multi-session continuity: Pick up where you left off days later Global Infrastructure Edge deployment: Runs in 330+ cities worldwide Low latency: Close to both users and AI model providers Automatic scaling: Handles traffic spikes without configuration Built-in reliability: Redundancy and failover included Development Experience Minimal boilerplate: Focus on business logic, not infrastructure Integrated auth: OAuth flows handled automatically Storage abstraction: Simple key-value interface for complex distributed storage Live development: Local development with production parity Quote "What if your agent was your backend? What if your MCP server automatically was able to hold that state, that storage for every user, and that was part of the MCP server itself?"