Guide
Cursor Mobile: iOS App, Android Status & How to Use It
Cursor for iOS is a native iPhone app in public beta for controlling agents that run in the cloud and on your local computer. You can start agents, follow their work, review and merge pull requests and hand off between local and cloud sessions. Android is planned, but not documented as shipped.
On this page
What changed in Cursor Mobile?
Cursor for iOS is a native iPhone app in public beta for controlling agents that run in the cloud and on your local computer. You can start agents, follow their work, review and merge pull requests and hand off between local and cloud sessions. Android is planned, but not documented as shipped.
- Release fact
- Native iOS app
- Why it matters
- Cursor's docs describe a beta iPhone app for controlling cloud and local agents.
- Release fact
- Same agent backend
- Why it matters
- The mobile app runs on the same backend as cursor.com/agents and the desktop Agents WindowCursor's surface listing your agent runs; open a run to read its diff and search transcripts from the command palette. Press Enter for the full definition..
- Release fact
- Practical job
- Why it matters
- Mobile matters most for checking agent progress, sending follow-ups and approving or redirecting work away from the desk.
- Release fact
- Plan and platform boundary
- Why it matters
- The app runs on iPhone with iOS 26.0 or later, in English; Android is planned.
- Release fact
- Buyer impact
- Why it matters
- Mobile shifts agent work from a desk-only workflow toward async supervision.
| Release fact | Why it matters |
|---|---|
| Native iOS app | Cursor's docs describe a beta iPhone app for controlling cloud and local agents. |
| Same agent backend | The mobile app runs on the same backend as cursor.com/agents and the desktop Agents WindowCursor's surface listing your agent runs; open a run to read its diff and search transcripts from the command palette. Press Enter for the full definition.. |
| Practical job | Mobile matters most for checking agent progress, sending follow-ups and approving or redirecting work away from the desk. |
| Plan and platform boundary | The app runs on iPhone with iOS 26.0 or later, in English; Android is planned. |
| Buyer impact | Mobile shifts agent work from a desk-only workflow toward async supervision. |
As of July 16, 2026. See the linked Cursor sources for the latest details.
This is covered hands-on in Cursor Compile 2026 — 1 short module, free to read.
How should a team use Cursor Mobile?
Knowing what shipped is the easy part. Turning Cursor Mobile into something a team relies on takes a few deliberate steps, mapped below.
- 1Use mobile for supervision and follow-up, not blind merge approval.
- 2Keep high-risk edits behind desktop review, tests and code-owner approval.
- 3Document which actions are safe from mobile: comment, redirect, inspect status and request evidence.
- 4Refresh the guidance when Android ships or Cursor changes beta availability.
What should stay bounded?
New capability comes with new ways to get it wrong. Keep these boundaries in place as you adopt it.
Do not position mobile as a replacement for full diff review.
Do not claim Android availability or general availability without an official source.
Keep secrets, production access and approval flows inside the same policy as desktop/cloud agents.
What does Cursor for iOS officially support?
Cursor for iOS is a beta native iPhone app for controlling agents in the cloud and on your local computer. It runs on the same backend as cursor.com/agents and the desktop Agents WindowCursor's surface listing your agent runs; open a run to read its diff and search transcripts from the command palette. Press Enter for the full definition., so agents you start from the phone show up in the other surfaces too.
- Capability
- Start and supervise agents
- Current source-backed boundary
- Choose a repository and branch, send a task and follow the agent as it works.
- Capability
- Review and merge
- Current source-backed boundary
- Review and merge pull requests from the iPhone app when the work is ready.
- Capability
- Local and cloud handoff
- Current source-backed boundary
- Control cloud agents or agents running on your computer from the phone.
- Capability
- Plan availability
- Current source-backed boundary
- Cursor documents the beta for Pro, Pro+, Ultra, Teams and Enterprise plans.
- Capability
- Platform boundary
- Current source-backed boundary
- The app runs on iPhone with iOS 26.0 or later, in English. Android is planned.
| Capability | Current source-backed boundary |
|---|---|
| Start and supervise agents | Choose a repository and branch, send a task and follow the agent as it works. |
| Review and merge | Review and merge pull requests from the iPhone app when the work is ready. |
| Local and cloud handoff | Control cloud agents or agents running on your computer from the phone. |
| Plan availability | Cursor documents the beta for Pro, Pro+, Ultra, Teams and Enterprise plans. |
| Platform boundary | The app runs on iPhone with iOS 26.0 or later, in English. Android is planned. |
The mobile app is useful for supervision and follow-up; keep high-risk merge decisions behind the same checks you use on desktop.
What is the recommended mobile development setup with Cursor?
Run the Agents window next to your native IDE as a sidecar. Cursor already writes Swift and Kotlin well; the missing piece is everything the native toolchain does (build, run the simulator, read logs, debug), and the sidecar pattern bridges that gap with flow moving in both directions.
The Agents window is the newer ground-up native desktop surface, not the VS Code fork. For mobile work you keep it open right alongside Xcode or Android Studio and jump back and forth. Open it with ⌘⇧P then View, switch to agents window, or the agents window button at the top right.
The native IDEs still own the build-and-run loop. Cursor drives the code; the sidecar carries information between the two.
the approach we're going to take today for mobile development is using that agent window as a sidecar to help enhance both iOS and Android IDEs and have the integration flow between the two in a bidirectional way
iOS: the Apple-maintained Xcode MCP server
On iOS the integration path is an MCPModel Context Protocol. A standard that lets an AI agent pull in context from outside the repo, like Jira tickets or internal docs. Press Enter for the full definition. server that Apple maintains inside Xcode. Xcode spins up the server, exposes its tools through an MCP bridge over its XPC protocol, and Cursor's MCP client discovers and calls them. That covers the parts Cursor cannot do natively: running the simulator, reading build logs, and debugging.
- Xcode MCP tool
- Apple SDK doc search
- What the agent gets
- Looks up framework APIs directly instead of guessing.
- Xcode MCP tool
- Render preview
- What the agent gets
- Screenshots the running simulator and hands the image to the agent.
- Xcode MCP tool
- REPL
- What the agent gets
- A live REPL the agent can drive to test a hypothesis.
| Xcode MCP tool | What the agent gets |
|---|---|
| Apple SDK doc search | Looks up framework APIs directly instead of guessing. |
| Render preview | Screenshots the running simulator and hands the image to the agent. |
| REPL | A live REPL the agent can drive to test a hypothesis. |
Apple ships and maintains this MCP server inside Xcode itself.
The agent makes a change, reruns the build, gets a screenshot of the UI, and iterates toward the expected end state. That is a real visual loop for mobile UI, the same way browser screenshots close the loop on the web.
one of my favorite ones of what's exposed is this render preview tool. And this will actually give screenshots of the simulator of the app running and give that to the agent.
The agent can bring up the simulator and take screenshots through render preview, but it cannot click around inside the simulator to drive flows. There is no agent-driven UI tapping today.
To test behavior, have Cursor write traditional unit tests. For running the simulator, Xcode's own infrastructure is the best integration available right now.
Android: ACP, MCP plugins, or both
Android Studio gives you three flavors, and you can mix them. The presenter still prefers the sidecar (CLI or Agents window) over chatting inside the IDE, but the in-IDE options exist when you want them.
- Option
- ACPAgent Client Protocol. An open standard that lets any IDE host any coding agent; Cursor uses it to run inside JetBrains/IntelliJ and Android Studio. Press Enter for the full definition. via JetBrains AI Assistant
- What it gives you
- The most direct in-IDE integration.
- Trade-off
- You lose debug mode and the better-hydrated rendering of info.
- Option
- IntelliJ MCPModel Context Protocol. A standard that lets an AI agent pull in context from outside the repo, like Jira tickets or internal docs. Press Enter for the full definition.-server plugins
- What it gives you
- Build, richer logs, and fine-grained debugging over MCPModel Context Protocol. A standard that lets an AI agent pull in context from outside the repo, like Jira tickets or internal docs. Press Enter for the full definition..
- Trade-off
- Heavier setup than ACPAgent Client Protocol. An open standard that lets any IDE host any coding agent; Cursor uses it to run inside JetBrains/IntelliJ and Android Studio. Press Enter for the full definition..
- Option
- Both combined
- What it gives you
- MCPModel Context Protocol. A standard that lets an AI agent pull in context from outside the repo, like Jira tickets or internal docs. Press Enter for the full definition. tools called from inside the ACPAgent Client Protocol. An open standard that lets any IDE host any coding agent; Cursor uses it to run inside JetBrains/IntelliJ and Android Studio. Press Enter for the full definition. chat, so the agent has all of it at once.
- Trade-off
- Most moving parts to configure.
| Option | What it gives you | Trade-off |
|---|---|---|
| ACPAgent Client Protocol. An open standard that lets any IDE host any coding agent; Cursor uses it to run inside JetBrains/IntelliJ and Android Studio. Press Enter for the full definition. via JetBrains AI Assistant | The most direct in-IDE integration. | You lose debug mode and the better-hydrated rendering of info. |
| IntelliJ MCPModel Context Protocol. A standard that lets an AI agent pull in context from outside the repo, like Jira tickets or internal docs. Press Enter for the full definition.-server plugins | Build, richer logs, and fine-grained debugging over MCPModel Context Protocol. A standard that lets an AI agent pull in context from outside the repo, like Jira tickets or internal docs. Press Enter for the full definition.. | Heavier setup than ACPAgent Client Protocol. An open standard that lets any IDE host any coding agent; Cursor uses it to run inside JetBrains/IntelliJ and Android Studio. Press Enter for the full definition.. |
| Both combined | MCPModel Context Protocol. A standard that lets an AI agent pull in context from outside the repo, like Jira tickets or internal docs. Press Enter for the full definition. tools called from inside the ACPAgent Client Protocol. An open standard that lets any IDE host any coding agent; Cursor uses it to run inside JetBrains/IntelliJ and Android Studio. Press Enter for the full definition. chat, so the agent has all of it at once. | Most moving parts to configure. |
Enable 'pass to IntelliJ MCP server' to expose Android-Studio-level MCP servers to Cursor.
For the MCPModel Context Protocol. A standard that lets an AI agent pull in context from outside the repo, like Jira tickets or internal docs. Press Enter for the full definition. route, enable the 'MCP server' pluginA Cursor marketplace package that bundles MCP servers and skills (sometimes sub-agents and hooks); one click installs all of it into your Cursor instance. Press Enter for the full definition. for broad IDE functionality plus a separate 'debugger MCP server' plugin. The debugger plugin exposes fine-grained control: set line breakpoints, conditional breakpoints, start, step out, step in.
Anything you would normally do by hand in the debugger UI becomes a tool the agent can call.
there's a debugger MCPModel Context Protocol. A standard that lets an AI agent pull in context from outside the repo, like Jira tickets or internal docs. Press Enter for the full definition. server, which... exposes again over an MCP server even finer control of debugging mechanisms... set line break points, conditional break points, start step out, step in, like anything you would probably do in the UI
React Native plus Expo: the lightest path
React Native is actually a smoother integration than native iOS or Android. Run the Expo server and it hot-reloads your changes, so you skip the whole build-and-run step that the Xcode and Android-Studio MCPModel Context Protocol. A standard that lets an AI agent pull in context from outside the repo, like Jira tickets or internal docs. Press Enter for the full definition. bridges exist to solve. The mental model: if the framework already gives you fast hot reload, you don't need the heavy MCP loop.
With Gemini 3.1 Pro you can ask Cursor to generate an image. It turns your prompt into an image prompt, then generates the asset, which is handy for app icons or any other mobile assets you need.
Do I need the iPhone app or the Xcode setup?
Two different jobs share the word mobile on this page, and they are worth separating before you set anything up. Cursor for iOS is the beta iPhone app for controlling agents away from your desk, on iPhone with iOS 26.0 or later. The Xcode and Android Studio MCPModel Context Protocol. A standard that lets an AI agent pull in context from outside the repo, like Jira tickets or internal docs. Press Enter for the full definition. bridges are for building mobile apps, at your desk, with the Agents window open beside the native IDE. Neither substitutes for the other.
If you are shipping an iOS app, the setup that changes your day is the second one, and I would start there rather than with the phone. The render-preview tool is the reason. It screenshots the running simulator and hands the image back, which closes the loop on UI work. The app on your phone does none of that. It supervises runs; it does not build or preview anything.
Which decisions are actually safe to make from the phone?
The app can review and merge pull requests, so this is a policy question rather than a capability one. The useful line runs between the decisions that are cheap to undo and the one that is not.
Commenting, checking status, asking for evidence, redirecting a run that has gone sideways. Those are all reversible in about a minute. A merge is not.
And what makes deferring the merge nearly free is the shared backend. The iPhone app, cursor.com/agents and the desktop Agents window all run on the same one, so a run you started on the phone is sitting there when you get back to a keyboard. Waiting costs you the walk to your desk, which is a low price for reading a diff at full size.
Which merges I would take from a phone probably depends more on your rollback story than on the phone.
Frequently asked questions
Who is this guide for?
Developers and team leads who want to monitor, redirect and review Cursor agent work away from the desk.
What should I do next?
Start with one real repo task, capture the prompt and review the result before scaling the workflow.
Is there a Cursor app for Android?
Not yet. The native app is iPhone-only (iOS 26.0 or later) and Cursor documents Android as planned. Android users can run and supervise the same agents today through the mobile web surface at cursor.com/agents, which shares the backend with the iOS app and desktop Agents window.
Is the Cursor mobile app free, or does it need a paid plan?
Cursor documents the iOS beta for Pro, Pro+, Ultra, Teams and Enterprise plans. The app itself is a free download; it is the agent usage behind it that draws from your plan, the same way desktop agent work does.
Can Cursor Mobile edit code directly on my phone?
No. It is not a phone IDE. The app starts, follows, redirects and reviews agent runs, and lets you review and merge the resulting pull requests. The agents do the editing in the cloud or on your computer; the phone is the supervision surface.
Can I control my desktop Cursor session from my phone?
Yes. The mobile app can control agents running on your own computer as well as cloud agents, because all three surfaces (iOS app, cursor.com/agents and the desktop Agents window) share one backend. Start work at your desk, then follow and redirect it from the phone.
How does Cursor integrate with Xcode for iOS development?
Through an MCP server that Apple maintains inside Xcode. Xcode exposes its tools over an MCP bridge, and Cursor's MCP client discovers and calls them. Standout tools include Apple SDK documentation search, a render-preview tool that screenshots the running simulator for the agent, and a REPL the agent can drive. Cursor already writes Swift; the MCP server covers running the simulator, reading build logs, and debugging.
Is Cursor for iOS generally available?
No. Cursor documents Cursor for iOS as a beta native iPhone app. It runs on iPhone with iOS 26.0 or later, in English, and Cursor says Android is planned.
Can the Cursor agent tap and click inside the iOS simulator?
Not yet. The agent can bring up the simulator and take screenshots through the render-preview tool, but it cannot click around inside the simulator to drive flows. To test behavior, have Cursor write traditional unit tests. For running the simulator, Xcode's own infrastructure is the best integration today.
Is React Native easier to use with Cursor than native iOS or Android?
Yes. With Expo you can run the Expo server, which hot-reloads changes, so you skip the build-and-run step that the Xcode and Android-Studio MCP bridges exist to solve. If your framework already gives you fast hot reload, you don't need the heavy MCP loop.
Sources & last verified
- Cursor blog: Cursor on web and mobile
- Cursor docs: Cursor for iOS
- Cursor blog: Build from anywhere with Cursor for iOS
- Cursor Community Forum: mobile app monitoring
- Cursor Community Forum: Compile 2026 announcements
- Cursor changelog: Cloud Environment Setup and Cloud Subagents
Cursor ships frequently. Facts verified against primary sources on July 9, 2026.
Keep reading
Rather do it than read about it? Run 11 interactive Cursor walkthroughs in a simulated editor. Free, no account needed.