When Amplitude added interactive UI to their MCP server, retention doubled. Not incrementally improved. Doubled. An engineer at the analytics company reported that users who could see charts, filter tables, and interact with visualizations directly inside Claude or ChatGPT — instead of receiving raw JSON — were twice as likely to keep using the integration.
That number should reframe how you think about MCP. Most companies shipping MCP servers today are treating them as protocol compliance checkboxes: expose the API as tool definitions, ship the server, check the box. But the data says the servers that survive are the ones designed as application surfaces, not API wrappers.
On July 2, 2026, Manufact — a Y Combinator S25 company — launched what it calls "MCP Cloud," positioning itself as Vercel for MCP servers. The launch post contains a detail that everyone glossed over but shouldn't have: major tech companies with MCP servers are already reporting that 15% or more of their total usage flows through MCP. Not 15% of API calls. Fifteen percent of product usage. If that number is even directionally accurate, MCP has crossed a threshold that most protocols never reach. It stopped being infrastructure that developers configure. It became a distribution channel that users discover organically.
From Protocol to Platform: The Nine-Month Sprint
The pace at which MCP transformed from a specification into a marketplace is worth mapping, because it happened faster than anyone predicted:
- October 2025. OpenAI shipped the ChatGPT Apps SDK, bringing app UIs into ChatGPT built on top of MCP. This was the first signal that MCP wouldn't stay confined to tool-calling.
- Late 2025. The stores opened. ChatGPT began accepting app submissions. Claude expanded its connector directory beyond selected partners.
- January 2026. MCP Apps became official. Proposal SEP-1865 merged as the first MCP extension —
io.modelcontextprotocol/ui— defining a single UI standard that any MCP host can render. - June–July 2026. All major clients — Claude, ChatGPT, Cursor — fully support MCP and operate reviewed marketplaces where servers can be one-click installed. Manufact launches as the deployment and monitoring infrastructure layer.
Nine months. That's how long it took MCP to go from "Anthropic's open protocol for tool calling" to "a marketplace economy where companies compete for discovery inside the most-used AI products on the planet." For context, the iPhone App Store launched in July 2008 — fifteen months after the SDK. MCP's marketplace layer materialized faster.
The UI Extension Is the Real Inflection
Here's what most teams missed about SEP-1865. The original MCP specification defined tools, resources, and prompts. It was designed for machines — the model calls a function, gets structured data back, processes it. Humans were an afterthought. The user never saw the tool call. They saw the model's interpretation of the result.
The UI extension changed that. MCP servers can now return fully interactive user interfaces — charts, tables, forms, buttons, branded layouts — that render natively inside ChatGPT, Claude, and any compliant host. This means an MCP server isn't just a tool definition anymore. It's an application that runs inside someone else's product.
Think about what that means for distribution. A company that ships an MCP server with UI support gets their branded experience rendered inside ChatGPT — which has hundreds of millions of users. They don't need to drive traffic to their own website. They don't need to win an SEO battle. They need to be the server that Claude or ChatGPT dynamically discovers when a user expresses relevant intent.
And that dynamic discovery is already happening. Clients are starting to present MCP servers and apps to users based on contextual intent, not manual installation. A user asks about their project analytics, and Claude surfaces the Amplitude MCP server. A user asks about a customer ticket, and ChatGPT surfaces the Zendesk app. This is the search-engine dynamic applied to agent integrations — and the same winner-take-all economics apply.
The Abandonment Problem
But here's the part the marketplace boosters aren't talking about. The Manufact founders included an uncomfortable observation in their launch post: most MCP servers are dead on arrival. They're built as 1:1 proxies of existing APIs — every endpoint mapped to a tool, every tool returning raw JSON. The user connects the server, asks one question, gets a wall of unstructured data, and never opens it again.
This is the "one-shot" problem. An MCP server that wraps an API without adding intelligence, formatting, or domain knowledge gets used once. The model calls the tool, gets back 500 rows of raw JSON, tries to summarize it, and produces a mediocre answer. The user concludes the integration is useless. They don't come back.
This mirrors the early App Store. In 2008–2009, thousands of companies shipped iPhone apps that were just their website rendered in a webview. They were slow, they were ugly, they didn't use any native capabilities. They got buried. The apps that survived were the ones designed for the platform — touch-first, offline-capable, using the camera and location services. The same shakeout is coming for MCP servers. The API wrappers will die. The MCP-native applications will thrive.
What Makes an MCP Server Survive
The servers that will capture marketplace attention share three characteristics. None of them are about the protocol. All of them are about product design.
Interactive UI, not raw data. The Amplitude data point is the proof. When users can see visualizations, interact with filters, and explore results inside the chat surface, retention doubles. Raw JSON is a developer experience. Interactive UI is a user experience. The servers that treat MCP as an application surface — with thoughtfully designed views, not just tool definitions — will win the retention battle.
Domain knowledge embedded in the server, not delegated to the model. A server that returns raw Salesforce records is relying on the model to interpret them. A server that returns "these three accounts have a 40% churn risk based on usage decline over 30 days" is doing the interpretation itself. The second is more reliable, more consistent, and more useful. This is the MCP equivalent of the skills concept: bundling expertise with capability. The server should know things the model doesn't.
Designed for multi-step workflows, not single queries. The one-shot problem kills servers that expose a single tool. The servers that survive expose composed workflows: "analyze this project, identify blocked tasks, and draft a status update" is three tool calls coordinated server-side. The user asks once. The server orchestrates. This is where the boundary between MCP server and agent becomes blurry — and that blurriness is the point. The best MCP servers will look more like embedded agents than API proxies.
The Distribution Land Grab
Paul Graham posted recently that if AI apps are the new browsers, then MCP servers are the new websites. That framing is directionally right but undersells the dynamic. Websites competed for search ranking. MCP servers compete for intent-based discovery inside a handful of dominant AI clients. There are far fewer discovery surfaces (ChatGPT, Claude, Gemini, Copilot) than there were search engines in the web era. The concentration is higher. The lock-in potential is greater.
Here's what that means in practice. When ChatGPT dynamically surfaces MCP servers based on user intent, the first server to claim a category wins disproportionate traffic. If the Zendesk MCP server is the one ChatGPT discovers when a user mentions support tickets, every competitor faces an uphill battle. Not because their server is worse — but because discovery is contextual, not searched. Users don't browse a directory. The client picks for them.
This creates urgency that most companies haven't internalized. The MCP marketplace is not a "nice to have" integration you'll get to eventually. It's a distribution channel where early movers capture disproportionate share. Every quarter you wait, a competitor's server gets more usage data, more marketplace reviews, more signal to the ranking algorithm. The cost of being late compounds.
The Infrastructure Layer Is Materializing
The Manufact launch signals something broader: the MCP ecosystem is developing its own infrastructure stack. Just as the web ecosystem produced hosting platforms (Vercel, Netlify), monitoring tools (Datadog, Sentry), and testing frameworks (Playwright, Cypress), the MCP ecosystem is building the same layers:
- Deployment: Manufact Cloud handles hosting, auto-deploy from GitHub, preview environments per branch, and custom domains — the same workflow Vercel normalized for web apps.
- Cross-client testing: Automated tests that install your MCP server in ChatGPT, Claude, and other clients to verify it works where users actually encounter it. This is the MCP equivalent of cross-browser testing.
- Observability: Session replay, tool-call analytics, latency tracking, and error monitoring designed specifically for MCP traffic patterns.
- Marketplace readiness: Automated checks against ChatGPT Apps Store and Claude Connectors submission requirements, with generated submission assets.
This infrastructure layer matters because it lowers the barrier to building production-grade MCP servers. Right now, most MCP servers are prototypes — local processes started manually, tested by connecting to a chat client and hoping it works. The tooling to build, deploy, and monitor them at production scale barely existed six months ago. It exists now, and the teams that adopt it will ship better servers faster.
What to Do This Week
Three actions, prioritized by urgency:
1. Audit your MCP server against the marketplace bar. If your server returns raw JSON with no UI, it will be one-shotted. If it delegates all interpretation to the model, it will produce inconsistent results. If it exposes individual API endpoints rather than composed workflows, it's an API wrapper pretending to be a product. Score yourself honestly. The servers that win marketplaces look like applications, not tool definitions.
2. Implement the UI extension. SEP-1865 is live. The io.modelcontextprotocol/ui standard lets you return interactive components from any MCP server. Start with your highest-traffic tool and add a visual view. Measure retention before and after. The Amplitude data suggests you'll see a significant lift — potentially the kind that changes the economics of the integration.
3. Submit to the marketplaces now, not later. The submission process is still manual and time-consuming. But being in the ChatGPT Apps Store and Claude Connectors directory is how you get dynamically discovered. Every day you're not listed is a day a competitor collects the intent-based traffic for your category. The ranking signals — usage volume, retention, reviews — compound over time. Being early is a structural advantage, not a convenience.
The Inflection We'll Remember
Protocol adoption is slow. Marketplace dynamics are fast. MCP spent 2025 convincing developers that a standard tool interface was worth adopting. It spent the first half of 2026 convincing companies that exposing their products through that interface was worth the engineering effort. The second half of 2026 will be about something different: competition for attention inside the marketplace.
The teams that recognize this shift — that MCP is no longer a protocol you implement but a distribution channel you compete in — will treat their MCP server the way the best companies treated their iPhone app in 2009: as a first-class product surface, designed for the platform, optimized for retention, and shipped before the competition claims the category.
The teams that don't will ship API wrappers, get one-shotted, and wonder why their MCP server has 15 users while a competitor's has 15,000. The protocol didn't fail them. The marketplace did what marketplaces do: it rewarded the best products and buried the rest.