MCP

Intent Surfaces

A reference manual for people who design and build MCP (Model Context Protocol) ecosystems

MCP

Intent Surfaces

A reference manual for people who design and build MCP (Model Context Protocol) ecosystems

MCP

Intent Surfaces

A reference manual for people who design and build MCP (Model Context Protocol) ecosystems

Beyond the Protocol

Beyond the Protocol

Beyond the Protocol

From isolated models to connected intelligence • What happens when every app speaks MCP • The protocol that changed everything

From isolated models to connected intelligence • What happens when every app speaks MCP • The protocol that changed everything

From isolated models to connected intelligence • What happens when every app speaks MCP • The protocol that changed everything

The Morning Everything Connected

The Morning Everything Connected

March 30, 2025, 7:00 AM. Sarah Chen opens her laptop. What happens next would have been science fiction just months ago.

March 30, 2025, 7:00 AM. Sarah Chen opens her laptop. What happens next would have been science fiction just months ago.

"Good morning," she says to her screen. Not to Claude. Not to any specific AI. Just... to her digital environment.

Her calendar responds first, through its MCP server:

"You have the architecture review at 9 AM."

Her IDE chimes in:

"The refactoring from yesterday is ready for review. All tests passing."

Her email client adds:

"Three messages need responses. I've drafted replies based on your communication style."

Her knowledge base contributes:

"Found two relevant papers for your review. Already cross-referenced with your notes."

"Good morning," she says to her screen. Not to Claude. Not to any specific AI. Just... to her digital environment.

Her calendar responds first, through its MCP server:

"You have the architecture review at 9 AM."

Her IDE chimes in:

"The refactoring from yesterday is ready for review. All tests passing."

Her email client adds:

"Three messages need responses. I've drafted replies based on your communication style."

Her knowledge base contributes:

"Found two relevant papers for your review. Already cross-referenced with your notes."

"Good morning," she says to her screen. Not to Claude. Not to any specific AI. Just... to her digital environment.

Her calendar responds first, through its MCP server:

"You have the architecture review at 9 AM."

Her IDE chimes in:

"The refactoring from yesterday is ready for review. All tests passing."

Her email client adds:

"Three messages need responses. I've drafted replies based on your communication style."

Her knowledge base contributes:

"Found two relevant papers for your review. Already cross-referenced with your notes."

This isn't multiple AIs. This is one intelligence flowing through every tool, understanding context across boundaries. This is what happens when MCP becomes invisible infrastructure.

This isn't multiple AIs. This is one intelligence flowing through every tool, understanding context across boundaries. This is what happens when MCP becomes invisible infrastructure.

The Great Convergence

The Great Convergence

By April 2025, something fundamental shifted. MCP wasn't just a protocol anymore—it was assumed, like TCP/IP or HTTP. Every new application launched with MCP support. Not having it was like launching a web service without an API.

By April 2025, something fundamental shifted. MCP wasn't just a protocol anymore—it was assumed, like TCP/IP or HTTP. Every new application launched with MCP support. Not having it was like launching a web service without an API.

Modern App

Modern App

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
// The new normal: Apps that assume MCP exists
class ModernApplication {
  constructor() {
    // MCP server is now part of basic app architecture
    this.mcpServer = new MCPServer({
      name: `${this.appName}-mcp`,
      version: '1.0.0',
      
      // Apps expose their capabilities by default
      capabilities: this.defineCapabilities(),
      
      // And discover others automatically
      discovery: {
        local: true,
        network: true,
        registry: 'mcp://discovery.local'
      }
    });
    
    // Apps can now assume AI assistance exists
    this.ai = new AmbientAI({
      context: 'local-first',
      privacy: 'maximum',
      capabilities: 'discovered'
    });
  }
  
  // Every app interaction is potentially AI-enhanced
  async handleUserAction(action) {
    // Traditional handling
    const result = await this.processAction(action);
    
    // But also expose to AI layer
    await this.ai.observe({
      action: action,
      result: result,
      context: this.getCurrentContext()
    });
    
    // AI might suggest improvements
    const suggestions = await this.ai.suggest();
    if (suggestions.confidence > 0.8) {
      this.showSuggestions(suggestions);
    }
    
    return result;
  }
}

11.1 The Connected Desktop

11.1 The Connected Desktop

The Composition Revolution

The Composition Revolution

When every app speaks MCP, composition becomes magical. Not just tools calling tools, but emergent workflows that no one explicitly programmed:

When every app speaks MCP, composition becomes magical. Not just tools calling tools, but emergent workflows that no one explicitly programmed:

Emergen Workflow

Emergen Workflow

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
// April 2025: The first "emergent workflow"
// This actually happened at a startup in San Francisco

/*
Developer says: "I need to analyze our customer churn and present findings to the board"

What happens next was not programmed, but emerged from MCP composition:
*/

// 1. The analytics MCP server responds
const churnData = await mcp.analytics.getChurnMetrics({
  timeframe: 'last-quarter',
  segments: 'auto-detect'
});

// 2. The database server notices the query pattern
const enrichedData = await mcp.database.enrichWithContext({
  data: churnData,
  context: ['customer-feedback', 'support-tickets', 'usage-patterns']
});

// 3. The visualization server sees structured data
const visualizations = await mcp.dataviz.createCharts({
  data: enrichedData,
  audience: 'board-level',
  style: await mcp.brandguide.getStyle('presentation')
});

// 4. The document server assembles everything
const presentation = await mcp.docs.createPresentation({
  title: 'Customer Churn Analysis Q1 2025',
  sections: [
    { type: 'executive-summary', data: await mcp.ai.summarize(enrichedData) },
    { type: 'visualizations', charts: visualizations },
    { type: 'recommendations', items: await mcp.ai.suggest(enrichedData) },
    { type: 'appendix', raw: enrichedData }
  ]
});

// 5. The calendar server notices "board" mention
await mcp.calendar.scheduleReview({
  document: presentation,
  attendees: ['ceo', 'cfo', 'vp-sales'],
  duration: '30min',
  ai_note: 'Pre-read attached, focus on recommendations'
});

// Total time: 47 seconds
// Manual process it replaced: 2-3 days

This wasn't a pre-programmed workflow. Each MCP server just did what it knew how to do, and the AI orchestrated them into something greater.

This wasn't a pre-programmed workflow. Each MCP server just did what it knew how to do, and the AI orchestrated them into something greater.

11.2 Emergent Workflow Builder

11.2 Emergent Workflow Builder

The Knowledge Fabric

The Knowledge Fabric

As MCP became universal, something profound emerged: a living knowledge fabric across all tools:

As MCP became universal, something profound emerged: a living knowledge fabric across all tools:

Knowledge Fabric

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
// The knowledge fabric pattern that emerged organically
// May 2025 - Started appearing in enterprises

class KnowledgeFabric {
  constructor() {
    // Every MCP server contributes to shared knowledge
    this.nodes = new Map();
    
    // Knowledge flows between servers automatically
    this.connections = new Graph();
    
    // AI understands relationships
    this.intelligence = new DistributedAI({
      model: 'local-first',
      federation: true
    });
  }
  
  // Example: How knowledge compounds
  async trace(concept) {
    // Start with a concept mentioned in email
    const emailMention = await mcp.email.find(concept);
    
    // Email links to document
    const document = await mcp.docs.get(emailMention.documentId);
    
    // Document references code
    const codeFiles = await mcp.git.findReferences(document.codeRefs);
    
    // Code has tests
    const tests = await mcp.testing.getTestsFor(codeFiles);
    
    // Tests have performance data
    const performance = await mcp.monitoring.getMetricsFor(tests);
    
    // Performance links to customer impact
    const customerImpact = await mcp.analytics.correlate(performance);
    
    // Everything is connected
    return {
      concept,
      graph: {
        nodes: [emailMention, document, codeFiles, tests, performance, customerImpact],
        edges: this.connections.findPaths(concept),
        insights: await this.intelligence.analyze(this.graph)
      }
    };
  }
}

// Real example from production
/*

Developer

What's the impact of the auth service latency?

Knowledge_Fabric

Knowledge Fabric traces:

Auth service code (Git MCP)

Performance metrics showing 200ms p99 (Monitoring MCP)

Customer sessions affected (Analytics MCP)

Support tickets mentioning slowness (Support MCP)

Business impact: $12K/day in lost conversions (Finance MCP)

Root cause: Database connection pooling (Database MCP)

Fix deployed 2 hours ago (Deployment MCP)

Impact recovering: -50% tickets in last hour (Support MCP)

All of this in 3.2 seconds.

Developer

What's the impact of the auth service latency?

Knowledge_Fabric

Knowledge Fabric traces:

Auth service code (Git MCP)

Performance metrics showing 200ms p99 (Monitoring MCP)

Customer sessions affected (Analytics MCP)

Support tickets mentioning slowness (Support MCP)

Business impact: $12K/day in lost conversions (Finance MCP)

Root cause: Database connection pooling (Database MCP)

Fix deployed 2 hours ago (Deployment MCP)

Impact recovering: -50% tickets in last hour (Support MCP)

All of this in 3.2 seconds.

Developer

What's the impact of the auth service latency?

Knowledge_Fabric

Knowledge Fabric traces:

Auth service code (Git MCP)

Performance metrics showing 200ms p99 (Monitoring MCP)

Customer sessions affected (Analytics MCP)

Support tickets mentioning slowness (Support MCP)

Business impact: $12K/day in lost conversions (Finance MCP)

Root cause: Database connection pooling (Database MCP)

Fix deployed 2 hours ago (Deployment MCP)

Impact recovering: -50% tickets in last hour (Support MCP)

All of this in 3.2 seconds.

11.3 Knowledge Fabric Explorer

11.3 Knowledge Fabric Explorer

The Local-First Revolution

The Local-First Revolution

As MCP spread, a counterintuitive trend emerged: AI became MORE private, not less:

As MCP spread, a counterintuitive trend emerged: AI became MORE private, not less:

First MCP

First MCP

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
// The local-first MCP architecture
// June 2025 - Privacy through ubiquity

class LocalFirstMCP {
  constructor() {
    // All MCP servers run locally
    this.servers = new LocalServerManager({
      storage: '~/.mcp/servers',
      data: '~/.mcp/data',
      
      // Nothing leaves your machine unless you say so
      network: {
        default: 'deny',
        allowed: ['explicit-consent-only']
      }
    });
    
    // Local AI models for sensitive operations
    this.ai = new LocalAI({
      models: {
        small: 'llama-3b-quantized',   // Runs on phones
        medium: 'mistral-7b-local',     // Runs on laptops
        large: 'llama-70b-distributed'  // Runs on local cluster
      },
      
      // Federated learning without data sharing
      federation: {
        enabled: true,
        protocol: 'secure-aggregation',
        differential_privacy: true
      }
    });
  }
  
  // Example: Private financial analysis
  async analyzeFinances() {
    // Your bank data never leaves your device
    const transactions = await this.servers.get('mcp-bank').getTransactions();
    
    // Analysis happens locally
    const insights = await this.ai.analyze(transactions, {
      model: 'medium',
      privacy: 'maximum'
    });
    
    // Only share aggregated insights if you choose
    if (await this.promptConsent('Share anonymous spending patterns?')) {
      await this.federation.contribute({
        insight_type: 'spending-patterns',
        data: this.differentialPrivacy.add_noise(insights.patterns),
        epsilon: 1.0
      });
    }
    
    return insights;
  }
}

// The paradox: More AI capability led to more privacy
// Because computation moved to the edge

11.4 Privacy Control Center

11.4 Privacy Control Center

The Ecosystem Network Effects

The Ecosystem Network Effects

By mid-2025, MCP's network effects became undeniable. Each new server made every existing server more valuable:

By mid-2025, MCP's network effects became undeniable. Each new server made every existing server more valuable:

MCP Ecosystem

MCP Ecosystem

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
// Network effect visualization
// July 2025 metrics

const mcpEcosystem = {
  servers: 50000,          // Active MCP servers
  connections: 1250000,    // Possible server combinations
  
  // Metcalfe's Law in action
  value: Math.pow(50000, 2), 
  
  // But actually more because of composition
  actual_value: factorial(50000) / factorial(50000 - 3), // 3-way combinations
  
  // New capabilities emerging daily
  emergence_rate: '~100/day',
  
  // Time to build new integration
  before_mcp: '2-4 weeks',
  with_mcp: '2-4 hours'
};

// Real example: The summer a teenager built something amazing
/*
August 2025: 16-year-old builds "Life OS" in a weekend

Combines:
- Calendar MCP (schedule)
- Fitness MCP (health)
- Nutrition MCP (diet)
- Learning MCP (education)
- Finance MCP (budget)
- Social MCP (relationships)
- Task MCP (productivity)

Creates: Holistic life optimization that suggests:
- When to exercise based on schedule and energy
- What to eat based on activities and goals
- When to study based on cognitive peaks
- How to balance social time with productivity
- Budget optimization for life goals

Goes viral. 2 million users in a month.
Total code written: 847 lines.
MCP servers doing the heavy lifting: 23.
*/

Value

Value

Value

11.5 Network Value Calculator

11.5 Network Value Calculator

The New Development Paradigm

The New Development Paradigm

MCP didn't just change how we build integrations—it changed how we think about software:

MCP didn't just change how we build integrations—it changed how we think about software:

MCP First Development

MCP First Development

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
// The new way of building applications
// September 2025 - Common in all modern frameworks

class MCPFirstDevelopment {
  // Old way: Build features, then maybe add AI
  // New way: Assume AI context from the start
  
  async designFeature(requirement) {
    // First question: What MCP servers could help?
    const relevantServers = await mcp.discovery.find(requirement);
    
    // Design with composition in mind
    const architecture = {
      core_logic: 'minimal',  // Just the unique part
      capabilities: relevantServers.map(s => s.provides),
      orchestration: 'ai-native',
      fallbacks: 'graceful-degradation'
    };
    
    // Generate implementation
    const implementation = await this.ai.generate({
      requirement,
      architecture,
      style: 'composition-first',
      tests: 'property-based'
    });
    
    // Time from idea to working feature: < 1 hour
    return implementation;
  }
}

// Example: Building a podcast app in 2025
const podcastApp = new App({
  unique_features: [
    'Beautiful interface',
    'Social listening parties'
  ],
  
  mcp_powered_features: [
    'Transcription (mcp-whisper)',
    'Search (mcp-elasticsearch)',
    'Recommendations (mcp-recommendation-engine)',
    'Episode summaries (mcp-summarizer)',
    'Clip creation (mcp-ffmpeg)',
    'Sharing (mcp-social-media)',
    'Analytics (mcp-analytics)',
    'Monetization (mcp-stripe)',
    'Comments (mcp-discourse)',
    'Live chat (mcp-websocket)'
  ]
});

// Development time: 1 week
// Features that would have taken 6 months: 10

10.6 Trust Score Calculator

10.6 Trust Score Calculator

The Great Simplification

The Great Simplification

As 2025 progressed, something unexpected happened: software got simpler:

As 2025 progressed, something unexpected happened: software got simpler:

Simplication

Simplication

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
// The code that disappeared
// October 2025 trend analysis

const simplificationMetrics = {
  average_app_loc: {
    2023: 50000,    // Lines of code
    2024: 35000,    // Some MCP adoption
    2025: 8000      // Full MCP adoption
  },
  
  integration_code: {
    2023: '40% of codebase',
    2024: '20% of codebase', 
    2025: '2% of codebase'
  },
  
  time_to_market: {
    2023: '6 months',
    2024: '2 months',
    2025: '2 weeks'
  },
  
  maintenance_burden: {
    2023: '60% of engineering time',
    2024: '30% of engineering time',
    2025: '5% of engineering time'
  }
};

// What engineers do now:
const modernEngineeringFocus = {
  creative_problem_solving: '40%',
  user_experience: '30%',
  composition_design: '20%',
  integration_maintenance: '5%',
  other: '5%'
};

// The paradox: Less code, more capability

Less code and more capability

Less code and more capability

Less code and more capability

11.7 Code Evolution Visualizer

11.7 Code Evolution Visualizer

The Ambient Intelligence

The Ambient Intelligence

By late 2025, AI through MCP became truly ambient—present but invisible, helpful but not intrusive:

By late 2025, AI through MCP became truly ambient—present but invisible, helpful but not intrusive:

Ambient Intelligence

Ambient Intelligence

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
// The ambient intelligence pattern
// November 2025 - The new normal

class AmbientIntelligence {
  constructor() {
    // AI observes but doesn't interrupt
    this.observers = new Map();
    
    // Learns your patterns
    this.patterns = new PatternLearner({
      privacy: 'local-only',
      adaptation: 'continuous'
    });
    
    // Acts when confident
    this.confidence_threshold = 0.9;
  }
  
  // Example: The day that felt magical
  async observeWorkDay() {
    // Morning: AI notices you always check certain metrics
    // Prepares dashboard before you ask
    
    // 9 AM: Meeting approaching
    // AI summarizes relevant documents, updates from last meeting
    
    // 10:30 AM: Code review time
    // AI has already run security checks, performance analysis
    
    // 12 PM: Lunch break pattern detected
    // AI schedules non-urgent tasks, enters do-not-disturb
    
    // 2 PM: Deep work session
    // AI maintains context, prefetches likely needed resources
    
    // 4 PM: End of day wrap-up
    // AI drafts status update, schedules tomorrow's priorities
    
    // Never intrusive, always helpful
    // You might not even notice it's there
  }
}

User feedback from November 2025

"I can't point to what AI does exactly. My day just flows better.

Things are where I need them, when I need them. It's like having

a really good executive assistant who's also invisible."

Software Engineer at Microsoft

User feedback from November 2025

"I can't point to what AI does exactly. My day just flows better.

Things are where I need them, when I need them. It's like having

a really good executive assistant who's also invisible."

Software Engineer at Microsoft

User feedback from November 2025

"I can't point to what AI does exactly. My day just flows better.

Things are where I need them, when I need them. It's like having

a really good executive assistant who's also invisible."

Software Engineer at Microsoft

11.8 Ambient AI Simulator

11.8 Ambient AI Simulator

The Protocol That Changed Everything

The Protocol That Changed Everything

As 2025 ends, MCP's impact is undeniable:

As 2025 ends, MCP's impact is undeniable:

What Changed

Integration complexity:
Solved

AI context boundaries:
Eliminated

Privacy concerns:
Addressed through local-first

Development speed:
10x improvement

Software simplicity:
Returned

What Emerged

Emergent workflows:
Unprogrammed collaboration

Knowledge fabric:
Connected understanding

Ambient intelligence:
Invisible assistance

Composition paradigm:
Building blocks, not monoliths

Human-AI partnership:
True collaboration

What's Next

The foundation is built. The ecosystem thrives. The protocol works.

But this is just the beginning...

11.9 Impact Dashboard

11.9 Impact Dashboard

Your Role in What Comes Next

Your Role in What Comes Next

As we stand at the threshold of 2026, you're not just learning about MCP—you're part of its future:

As we stand at the threshold of 2026, you're not just learning about MCP—you're part of its future:

Opportunity

Opportunity

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// The opportunity ahead
const yourOpportunity = {
  // Problems yet to solve
  unsolved: [
    'Cross-language MCP bridges',
    'Quantum-safe MCP security',
    'MCP for embedded systems',
    'Biological data MCP servers',
    'MCP mesh networking'
  ],
  
  // Industries yet to transform
  industries: [
    'Healthcare diagnostics',
    'Educational personalization',
    'Scientific research',
    'Creative arts',
    'Urban planning'
  ],
  
  // Your contribution awaits
  get_started: 'https://github.com/modelcontextprotocol',
  join_community: 'Discord/MCP',
  build_something: 'amazing'
};

The protocol is written. The patterns are proven. The ecosystem welcomes you. What will you build?

The protocol is written. The patterns are proven. The ecosystem welcomes you. What will you build?

Connect with

other builders

Your goals

Connect with

the mentor

Your interests

and skills

11.7 Code Evolution Visualizer

11.7 Code Evolution Visualizer