MCP was specced for desktop hosts. The mobile reality — battery limits, OS sandboxes, intermittent network — adds constraints the spec did not anticipate. Here is the architecture for shipping a mobile MCP client and the platform-specific gotchas.
The shape of a mobile MCP client
Three layers, none optional:
1. Host runtime
The agent loop, model client, and message orchestration. Lives in the app process.
2. Transport
HTTPS+SSE or WebSocket to remote MCP servers. Stdio is not viable on mobile (no subprocess).
3. Local tools
Some tools run in the app: contacts, calendar, files. These are MCP servers running in the app's own runtime.
What to host where
| Tool category | Host |
|---|---|
| User's local data (contacts, calendar) | In-app MCP server |
| Heavy lifting (search, summarisation) | Remote MCP via gateway |
| Authentication / identity | OS-native (iOS Keychain, Android Keystore) |
| Push for incoming messages | OS-native + remote |
Mixing local and remote MCP is the rule, not the exception.
iOS specifics
Five gotchas:
Background time
iOS aggressively suspends apps. An MCP session in flight when the user switches apps may be killed. Use BGTaskScheduler for long agent runs; show a UI affordance for user-initiated foreground tasks.
App Transport Security
All MCP transport must be TLS 1.2+ with valid certificates. No localhost exception without explicit ATS configuration; usually not worth fighting.
Microphone and camera consent
For voice or visual agents, every session needs permission. Plan UX around denials.
Storage class
Memory and audit logs go in Documents (user-visible) or Application Support (user-invisible). Pick deliberately for the right backup behaviour.
Push for tool callbacks
APNs push to wake the app for an incoming MCP event (rare but useful for collaboration agents).
Android specifics
Five gotchas:
Doze mode
Android similarly suspends. Use WorkManager for scheduled agent work. Foreground Service for user-initiated long runs (with the now-standard notification).
Network types
Android exposes whether you are on Wi-Fi vs cellular vs metered cellular. Adapt cost-heavy MCP calls to the network type — particularly for a voice or vision agent.
Per-app VPN
Some enterprise contexts require all MCP traffic through a per-app VPN. Plan for the latency.
Permissions modal flows
Runtime permissions are denied silently more often than on iOS. Build a graceful degradation path for every protected tool.
Background location
If your agent needs location, the rules are strict and changing. Avoid unless absolutely necessary.
React Native and Flutter
The cross-platform story is improving but not parity:
- React Native: an
mcp-client-rnlibrary exists; bridges to native HTTPS and SSE. - Flutter: community packages; less mature.
- Capacitor: thinnest layer over native; usually the right pick for MCP-heavy apps.
If your app is already React Native, stay there. If you are starting fresh and MCP-heavy, native gives more control.
Battery as a first-class concern
Mobile MCP clients drain battery faster than chat clients. Three levers:
- Cache aggressively — see caching strategies. Less radio = more battery.
- Pre-fetch on Wi-Fi — speculatively load context that might be needed.
- Throttle background work — agents should not poll on cellular.
A naive mobile MCP client can drain a phone in 4 hours. A well-engineered one matches a chat app.
On-device model integration
iOS 18+ ships Apple Intelligence; Android 16 ships Gemini Nano on supported devices. Both expose a local model API. Pattern:
incoming user request
↓
classify: easy or hard?
↓ easy ↓ hard
on-device model remote MCP + frontier model
↓ ↓
return return
Saves cost, improves privacy. See on-device inference.
Authentication
OAuth via the OS-native browser flow (ASWebAuthenticationSession on iOS, Custom Tabs on Android). Tokens in Keychain / Keystore. Refresh handled by a background agent.
See agent SSO patterns for the broader story.
Common mistakes
- Trying to run stdio MCP servers on mobile — not possible; use HTTPS+SSE.
- Ignoring battery telemetry — Apple's Energy organiser and Android's Battery Historian will tell you what is wrong.
- No offline path — agents that hang on a flaky connection lose users fast.
- Backgrounding mid-session — handle gracefully or warn explicitly.
Where this is heading
Three trends by 2027: native MCP client SDKs from Apple and Google, OS-blessed background patterns for agent work, and cross-app MCP discovery within iOS/Android. Build with the patterns above; the SDKs will smooth the rough edges.