Skip to main content
All posts

MCP Needs a Browser (September 2026)

Abe Wheeler
MCP AppsChatGPT AppsClaude ConnectorsMCP App FrameworkMCP App TestingMCPBrowser
MCP needs browser-like discovery, connection, and interaction patterns before MCP servers feel natural to everyday users.

MCP needs browser-like discovery, connection, and interaction patterns before MCP servers feel natural to everyday users.

MCP has spent the past year and a half learning from the web. The newest protocol can run as ordinary stateless HTTP. The official Registry gives public servers a shared metadata layer. OAuth discovery uses well-known documents. MCP Apps put sandboxed HTML inside compatible hosts.

Those are strong protocol primitives, but a protocol is not the whole user experience. People still need to find the right server, know who published it, connect with the right permissions, understand what an action will do, and use the result without reading raw JSON or trusting a model to sequence every step.

That is what it means to say MCP needs a browser.

TL;DR: MCP now has several pieces of a browser-like layer: the preview Registry for public metadata, Server Card work for server-owned discovery, server/discover for protocol negotiation, OAuth metadata for connection, and MCP Apps for interactive UI. They solve different problems and do not create trust by themselves. Builders should keep tools useful without UI, publish accurate metadata, use current HTTP and OAuth contracts, and test the full workflow across hosts.

What the Browser Analogy Actually Means

A browser does more than render HTML. It gives the web a common set of product rules around identity, navigation, permissions, isolation, and recovery. MCP needs equivalent jobs, even if no single app owns all of them.

Browser jobCurrent MCP primitiveWhat is still missing
Find a siteOfficial MCP Registry and downstream catalogsConsistent ranking, curation, private discovery, and adoption by hosts
Inspect identityVerified Registry namespaces and future Server CardsA familiar, host-wide trust signal for publishers and deployments
ConnectStreamable HTTP, server/discover, and host connector setupQuiet setup that still exposes meaningful risk and compatibility
Grant accessOAuth protected resource metadata, scopes, and host approval UIConsistent least-privilege and step-up flows across hosts
Use softwareMCP tools, resources, and MCP AppsBroad extension support and predictable host capabilities
Isolate contentSandboxed iframes, CSP, and declared permissionsClear user controls, audit views, and recovery when an app misbehaves

The analogy also has a limit. An MCP host is not a general web browser, and an MCP server is not a website. The model can choose and call tools on a user’s behalf. A View runs inside a host-controlled sandbox. The host mediates capabilities, permissions, and conversation context. That extra actor changes the threat model, so a familiar interface cannot replace explicit authorization and server-side policy.

1. Discovery Needs an Index and a Server-Owned Record

A user looking for a company’s MCP server should not need to search source repositories, compare copied setup commands, and guess which endpoint is official.

Elderly couple struggling to discover and understand MCP servers

The official MCP Registry is now the shared metadata source for publicly accessible servers. It is still in preview. A publisher submits a versioned server.json record that can identify a public package or a remote Streamable HTTP endpoint. Reverse-DNS names tie the listing to a verified GitHub account, domain, or HTTP namespace.

The Registry deliberately does less than an app store. It hosts metadata and checks namespace ownership. It does not host package binaries, scan every server’s code, rank search results, or certify that a tool is safe. Downstream catalogs and marketplaces are expected to consume the Registry API and add search, ratings, policy, or security data. The official docs also say hosts should consume those downstream catalogs rather than query the official Registry directly.

MCP Server Cards address a different part of discovery. The working group is defining a server-owned document and a standard way to find it, such as a well-known URL. That would let a client or crawler inspect a server before opening an MCP connection. The format remains working-group output, so it should not be confused with the Registry’s current server.json schema or with runtime discovery.

Builders can act now without guessing the final Server Card shape:

  • Publish an accurate Registry record for a public server or package.
  • Keep the product name, owner, repository, remote URL, version, and transport metadata consistent.
  • Document authentication, required scopes, data handling, support, and destructive actions on a stable HTTPS page.
  • Use a domain or GitHub namespace you control, and treat every release as a metadata release too.
  • Do not claim that a Registry listing is a security review.

2. Connection Now Looks More Like Normal HTTP

The web scales because a request can reach any healthy server behind a load balancer. Early MCP revisions carried protocol state through an initialization handshake and optional transport sessions, which made remote deployments feel different from ordinary HTTP services.

Man struggling through a barrage of disclaimers, popups, terms, and connection steps

The MCP 2026-07-28 release introduced a new stateless protocol era. It removed the initialize / notifications/initialized exchange and Mcp-Session-Id from that era. Protocol version and client capabilities travel with each request, while server/discover lets a client ask for supported versions and capabilities before making another call. List responses can carry cache hints, and Streamable HTTP mirrors method and tool names into headers so gateways can route and meter traffic without parsing every JSON body.

This does not mean every deployed host and SDK changed on the same day. Older protocol revisions still use the handshake, and some current SDKs require an explicit opt-in before they speak 2026-07-28. A production client needs version negotiation or a known compatibility target. A production server needs tests for the protocol eras and hosts it claims to support.

For new remote work, use Streamable HTTP. The old HTTP+SSE transport is deprecated with a migration window, while stdio remains the standard binding for client-launched local servers. Do not add sticky sessions just because an older MCP example used them. Keep application state explicit, such as a durable workflow ID returned by one tool and passed to the next.

3. Authentication Needs Browser-Grade Defaults

Connection is not only a transport problem. A host needs to discover where authorization happens, register or identify itself, ask for the right scopes, bind tokens to the intended MCP server, and recover when a later action needs more access.

The MCP 2026-07-28 authorization specification builds that flow from web standards:

  1. A protected MCP endpoint returns HTTP 401 with a WWW-Authenticate challenge that points to OAuth Protected Resource Metadata.
  2. The metadata names the authorization server and the scopes relevant to the resource.
  3. The client uses a Client ID Metadata Document, pre-registration, or legacy Dynamic Client Registration. The current specification prefers CIMD and deprecates DCR.
  4. Authorization and token requests include the MCP server’s canonical URI as the OAuth resource indicator.
  5. The server validates issuer, audience, expiry, signature, scopes, and the user or tenant before running a tool.
  6. A later operation that needs more scope returns HTTP 403 with one complete insufficient_scope challenge, so the client can perform a bounded step-up flow.

These rules create a predictable connection contract, but the host still owns the user experience. A good host can show the publisher, requested scopes, tool risk, and account being connected without dumping protocol terms on the user. A good server supports that UI with narrow scopes, plain tool descriptions, correct HTTP errors, and no token forwarding.

4. Use Needs Deterministic UI

Text and structured tool results work well when a user wants an answer. They work less well when a user needs to compare records, edit a form, inspect a map, review a diff, choose among images, or confirm a consequential action.

Computer struggling to understand a complicated network of API calls

MCP Apps provide the browser-like rendering layer. A tool declares _meta.ui.resourceUri, the host fetches the matching ui:// HTML resource, and the host renders it in a sandboxed iframe. The View and host communicate with JSON-RPC over postMessage, so the app can receive tool input and results, call permitted server tools, send messages, update model-visible context, and request host actions when those capabilities are available.

UI is progressive enhancement. A client and server must negotiate the MCP Apps extension, and support varies. The tool should still return useful content and structuredContent when a client cannot render the View. This fallback matters for command-line clients, model-only execution, accessibility, debugging, and new hosts that have not implemented the extension yet.

ChatGPT’s current guidance starts with the open MCP Apps contract, then layers optional window.openai features such as ChatGPT file handling, checkout, and host-controlled modals behind feature detection. Claude custom connectors can render interactive inline cards and fullscreen Views. Other hosts support different subsets. Build the portable bridge first, then test the exact capability you need instead of branching on a product name.

5. Trust Needs More Than a Listing or a Sandbox

A browser padlock never meant a website was honest. In the same way, a verified Registry namespace, valid OAuth flow, or sandboxed MCP App does not prove that a server will use data responsibly.

Each layer answers a smaller question:

SignalWhat it tells youWhat it does not tell you
Registry namespaceThe publisher controls the claimed GitHub account or domainThe server is secure, useful, or maintained
HTTPSTraffic reaches the certificate holder without network tamperingThe endpoint deserves access to user data
OAuth scopesThe token is limited to declared permissionsEvery tool call is appropriate for this object and user
Tool annotationsThe server describes a tool as read-only, destructive, idempotent, or open-worldThe description is true or enforced
MCP App sandboxThe View cannot directly read host DOM, cookies, or storageThe server cannot misuse data sent through authorized tools
CSP and permissionsThe View declares allowed network, asset, camera, microphone, or location accessThe allowed destinations are trustworthy

Servers must enforce authorization at the object and operation level. Separate read tools from write tools. Put destructive actions behind clear confirmation with a reviewable summary. Use idempotency keys for retries. Keep app-only interaction tools out of model context when the model does not need them. Log the actor, account, tool, target object, result, and policy decision without logging secrets.

Hosts need equally clear controls: connected account, active scopes, per-tool approval, revocation, recent activity, and an obvious way to disable a server. Those controls are the MCP equivalent of browser site settings and history.

6. Builders Need to Test the Whole Browser-Like Path

A direct tools/call test proves only that the handler returns a result. It does not prove that a user can discover the server, complete OAuth, approve the right action, load the View, use it in a narrow iframe, recover from an expired token, or get a useful fallback in a client without MCP Apps.

Use a layered release gate:

BoundaryMinimum evidence
DiscoveryValid server.json, controlled namespace, accurate package or remote URL, working docs and support links
ProtocolVersion negotiation, server/discover where supported, tools/list, resources/list, cache behavior, and legacy compatibility if claimed
AuthorizationProtected resource metadata, issuer and audience checks, least-privilege scopes, 401 and 403 challenges, token expiry, and revocation
Tool behaviorRuntime schema checks, object authorization, ordinary assertions, retries, idempotency, and useful model-visible fallback content
MCP App ViewTool-resource linkage, iframe startup, tool input and results, loading, error, empty, cancellation, and teardown
Host behaviorTheme, display mode, safe area, container size, permissions, host extensions, caching, and unsupported-capability fallbacks
ProductionPublic HTTPS endpoint, real OAuth redirect, deployed assets and CSP, observability, rate limits, rollback, and narrow live-host smoke tests

Run most of this deterministically and reserve live-host tests for host behavior you cannot reproduce. That keeps feedback fast while still checking the last mile before a release.

Where sunpeak Fits

sunpeak provides a local MCP App Inspector with replicated ChatGPT and Claude runtimes. It can call tools, load ui:// resources, switch host shells, change themes and display modes, pin tool states with simulations, and run Playwright E2E and visual tests in CI without using host credits for every edit.

As of September 2026, sunpeak 0.20.x uses @modelcontextprotocol/ext-apps 1.7.5 and @modelcontextprotocol/sdk 1.30.0. Its MCP Apps View protocol is wire-compatible with Views and hosts built on ext-apps 2.x. Its generated MCP server path still uses the pre-2026 core protocol by default, so teams adopting core MCP 2026-07-28 should add protocol-version tests with a current v2 MCP SDK while keeping their View tests in sunpeak.

For a new MCP App, run:

npx sunpeak new

For an existing server, point the Inspector at it:

npx sunpeak inspect --server https://mcp.example.com/mcp

MCP has more of the browser layer than it did three months ago. The work now is to connect those pieces honestly: public metadata that can be discovered, HTTP and OAuth contracts that hosts can automate, UI that degrades to useful tool results, server-side authorization that does not trust the model, and tests that cover the full path a user takes.

Get Started

Documentation →
npx sunpeak new

Further Reading

Frequently Asked Questions

Why does MCP need a browser-like experience?

MCP standardizes how clients call tools and read resources, but users also need to find servers, verify who published them, connect safely, understand permissions, and interact with rich results. Browsers made those jobs predictable for the web. MCP is building similar primitives through the official Registry, Server Card work, OAuth metadata, host approval UI, and MCP Apps.

What changed in the MCP 2026-07-28 specification?

MCP 2026-07-28 removed the protocol-level initialize handshake and session ID from the new protocol era. Each request carries its protocol version and client capabilities, server/discover can report supported versions and capabilities before a call, list results can be cached, and Streamable HTTP requests expose routing metadata in headers. Older protocol revisions and SDK defaults still exist, so clients and servers need an explicit compatibility plan.

What is the official MCP Registry?

The official MCP Registry is a preview metadata service for publicly accessible MCP servers. Publishers submit a versioned server.json record that can point to public packages or remote Streamable HTTP endpoints. The Registry verifies namespace ownership and exposes an API, while downstream catalogs add search, curation, ratings, and security checks. A Registry listing does not mean the server code was security-reviewed.

What are MCP Server Cards?

MCP Server Cards are still being defined by the MCP Server Card Working Group. The goal is a standard document, likely discoverable through a well-known URL or similar mechanism, that lets a client learn about a server without opening an MCP connection. Server Cards are separate from the Registry and server/discover, so builders should not treat a draft card shape as a stable production contract yet.

How do MCP Apps provide a browser-like UI layer?

An MCP tool can reference a ui:// HTML resource through _meta.ui.resourceUri. A compatible host fetches that resource, renders it in a sandboxed iframe, and connects the View through a JSON-RPC bridge over postMessage. The UI can receive tool input and results, call allowed server tools, and request host actions. MCP Apps are progressive enhancement, so the underlying tool should remain useful in clients that do not render UI.

Does an MCP Apps iframe make an MCP server safe?

No. The iframe isolates the View from the host DOM, cookies, and storage, and resource CSP limits network and asset origins. Those controls reduce UI risk, but they do not validate the server, authorize a user, or make a destructive tool safe. Servers still need token audience checks, object-level authorization, least-privilege scopes, runtime input validation, confirmations, and audit logs.

How do ChatGPT Apps and Claude Connectors fit into MCP Apps?

ChatGPT implements the open MCP Apps standard and adds optional ChatGPT-specific extensions. Claude custom connectors can expose MCP tools and interactive inline or fullscreen UI. Build the shared tool, resource, and View bridge contract first, then feature-detect host extensions and test each host because capabilities, display modes, authentication, caching, and host chrome differ.

How can I test MCP Apps locally without paid host accounts?

sunpeak provides a local MCP App Inspector with replicated ChatGPT and Claude runtimes. It can render tool-linked resources, switch hosts, themes, display modes, and devices, pin tool states with simulations, and run E2E and visual tests in CI. Use those deterministic tests for the normal development loop, then keep a small set of live-host checks for behavior only the production host can prove.