We Built Bridges to AI, But Not Between Our Tools

Moved from Medium. Original Post Date: June 28th 2025.

Aug 01, 2025

I was deep in a conversation with Claude on my desktop, working through a complex problem. We’d explored the architecture, discussed trade-offs, and sketched out some code. Then I realized I needed to switch to Claude Code to actually implement it.

Starting over in a new chat felt like leaving a good conversation mid-sentence.

This friction point revealed something profound: We have the Model Context Protocol (MCP) connecting AI to tools. But we’ve only solved half the problem. What if we could build on MCP’s success to create something bigger — a Universal Context Protocol (UCP) that connects ALL our tools through shared context?

MCP’s Success Shows the Way

MCP proved something important: tools can communicate through standardized protocols. It elegantly solved AI-to-tool communication:

Claude → (MCP) → Your Database
Claude → (MCP) → Your Files
Claude → (MCP) → Your APIs

But our tools still can’t talk to each other:

Figma ❌ Cursor
Claude Desktop ❌ Claude Code
Your IDE ❌ Your Design Tools

We’ve built bridges to AI, but not between our tools. It’s like having phones that can only call the operator, not each other.

Introducing UCP: Universal Context Protocol

What if we leveraged MCP’s architecture to create UCP — a protocol specifically designed for tool-to-tool context sharing?

MCP (Model Context Protocol):
Tool ←→ AI Model

UCP (Universal Context Protocol):
Tool ←→ Shared Context ←→ Tool
         ↑
    AI (via MCP)

UCP wouldn’t replace MCP — it would complement it. MCP handles AI connections. UCP handles everything else.

How UCP Would Work

Note: This example is simplified to demonstrate the concept. Real implementation would require sophisticated protocols, but the principle is clear:

# Project context accessible via UCP
project: RealtimeCollaboration
ucp_id: "rtc-2024-03"

# Tools register with UCP
registered_tools:
  - name: "Claude Desktop"
    mcp_enabled: true
    publishes: ["decisions", "explorations"]
    subscribes: ["code_changes", "design_updates"]
    
  - name: "Figma"
    mcp_enabled: false
    publishes: ["design_tokens", "components"]
    subscribes: ["code_constraints", "decisions"]
    
  - name: "Cursor"
    mcp_enabled: true
    publishes: ["code_patterns", "implementations"]
    subscribes: ["design_tokens", "architecture"]
# Live context flow via UCP
context_streams:
  design_decisions:
    source: "Figma"
    data: {colors: "#FF6B6B", animations: "200ms ease"}
    subscribers: ["Cursor", "Claude Desktop", "Claude Code"]
    
  architecture_choices:
    source: "Claude Desktop"
    data: {pattern: "WebSocket", reason: "existing infrastructure"}
    subscribers: ["Cursor", "Figma", "Documentation"]
    
  implementation_status:
    source: "Cursor"
    data: {feature: "cursor_tracking", status: "complete"}
    subscribers: ["Claude Code", "Project Manager"]

UCP + MCP: The Complete Picture

The beauty is how they work together:

MCP connects AI to individual tools (proven, working today)
UCP connects tools to each other through shared context (the missing piece)
AI becomes smarter because it can see the full context via both protocols

Your workflow becomes:

Open any tool → UCP provides full project context
Need AI help → MCP connects to AI with rich context
Switch tools → Context flows seamlessly via UCP
Collaborate → Everyone shares the same living context

What UCP Enables

True Continuity: Start in Claude Desktop, continue in Claude Code — same conversation, because UCP maintains the thread.

Real-time Sync: Change a design token in Figma, your IDE instantly knows via UCP. No manual updates, no disconnected systems.

Tool Intelligence: Every tool understands what every other tool is doing. Your IDE knows what you designed. Your design tool knows your code constraints.

Project Memory: Your project’s context lives independently, accessible via UCP. It’s yours, not trapped in any tool.

Why This Completes the AI OS

An operating system needs:

Resource Management: UCP manages context as a shared resource
Inter-Process Communication: UCP is literally IPC for the AI age
Standard Protocols: MCP for AI, UCP for everything else
Security Layer: UCP can handle permissions and access control

We don’t need to replace traditional operating systems. We need to add the context layer they’re missing — and UCP can be that layer.

Breaking Free from Tool Prisons

Today’s “project” features fail because they’re silos:

Claude Projects → Locked in Claude
Claude Code’s .md → Stuck in Claude Code
Cursor’s context → Trapped in Cursor

With UCP:

Project context lives independently
Tools connect through UCP to access it
Context flows freely between everything
You own your project’s memory
MCP still handles AI connections

The Path Forward

This isn’t starting from scratch — it’s building on what works:

Leverage MCP’s design principles for UCP
Define context schemas that any tool can use
Build UCP adapters for popular tools
Create bridges between UCP and MCP
Open source everything to drive adoption

The best part? Tools that already support MCP are halfway there. They know how to speak protocol — they just need to speak to each other.

The Last Mile to the AI OS

We have MCP connecting tools to AI. We just need UCP connecting tools to each other. Together, they form the nervous system of an AI Operating System.

Imagine opening any tool and having it instantly understand your entire project context. Imagine AI that can see not just what you’re asking, but everything you’ve done across all your tools. Imagine never losing context again.

That’s not science fiction — it’s one protocol away. We built bridges to AI. Now let’s build bridges between everything else.

The question is: who will be first to realize that UCP is the missing piece that makes everything connected?

Would you use a protocol that let all your tools share context? What would you build if context could flow freely between everything?

Ali Builds

Discussion about this post