For your role
Cursor for Mobile Engineers: iOS, Android, React Native
Run Cursor next to Xcode or Android Studio and let the agent call the IDE's tools. Xcode 26.3 and later include an MCP server that lets the agent build, run tests and capture previews. Android uses JetBrains' AI Assistant (ACP) or IntelliJ MCP plugins. In Cursor's mobile workshop, the presenter found that React Native with Expo skips the build loop.
On this page
- How do you use Cursor for mobile development?
- How do you connect Cursor to iOS and Xcode?
- How do you set up the Xcode MCP server?
- How do you connect Cursor to Android Studio?
- What does the ACP route leave out?
- Which model should you use for mobile MCP work?
- What about React Native and Flutter?
- Should mobile build profiles be skills or rules?
How do you use Cursor for mobile development?
Run Cursor next to your native IDE and let the agent reach into it, a setup Cursor's mobile development workshop calls the sidecar pattern. Cursor can already write Swift, the presenter noted, so what it lacks on mobile is the loop around the code: the simulator, the debugger and real build logs. Xcode or Android Studio stays open for those, and the agent calls into the IDE through 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. or 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. bridge.
In the workshop, the sidecar is the 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., Cursor's agent-first interface. To open it from the editor, press Cmd+Shift+P and choose Open Agents Window. The presenter also used an Agents Window button at the top right. You can switch back to the editor at any time, or keep both open.
"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."
Interactive widget. Tab through its controls; the result updates in the panel below as you change them.
Rules give guidance, skills package a workflow the agent runs, and MCP servers expose the IDE's build and debug tools. The mobile setups on this page lean on skills and MCP.
What is inside the Agents Window?
The demo showed three regions: a main prompt window for starting agents, an agent pane at the top left, and an inspection panel on the right. The agent pane holds several workspaces at once, so an iOS repo and an Android repo can share one window, with agents running in both. As the presenter put it, "each workspace you open will contain its own indexing."
- Agent pane (top left)
- Open several workspaces, run agents across them and watch their progress. Cloud AgentsAgents that run in a Cursor-managed virtual machine, check out the repo, do the work and open a pull request, then shut down, with no load on your laptop. Press Enter for the full definition. appear here too.
- File browser
- Inspect the repo the traditional way.
- Terminal
- Each running agent gets its own sandbox terminal.
- Cursor browser
- The agent can test its changes in an integrated browserCursor's built-in browser, driven by Playwright under the hood, so the agent can navigate, click, screenshot and capture each action's metadata while you watch. Press Enter for the full definition..
- Review pane
- The agent reviews its own diff, and you create branches and commit from here.
In the demo, the current branch shows at the top right, and on the review tab once there are changes. To move changes you made on main to a new branch, click the arrow to the right of the commit-and-push button, create the branch and commit there.
This is covered hands-on in Cursor Software Engineer, Product Interview Prep — 7 short Units, free to read.
How do you connect Cursor to iOS and Xcode?
Use 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. server built into Xcode. Cursor's Xcode docs say Xcode 26.3 and later include it, along with a bridge binary that translates MCP messages into Xcode's internal XPC layer. MCP (Model Context Protocol) is the standard that exposes tools to the model during an agent run, and Cursor treats Xcode's built-in tools like any other MCP server. With them, the agent can edit files, build the active scheme, run tests, read build logs, capture SwiftUI previews and search Apple's documentation.
Three of those tools stood out for the presenter: a search over Apple's SDK documentation, a REPL the agent can drive, and the render-preview tool. The presenter's own workflow was built around the last one.
The presenter's description: "...this render preview tool. And this will actually give screenshots of the simulator of the app running and give that to the agent." Cursor's Xcode docs describe the tool more narrowly: it captures a screenshot of a SwiftUI preview.
Each pass of the presenter's loop goes the same way: the agent makes a change, rebuilds, gets a screenshot of the UI and iterates toward the end state you described. Cursor's documented example workflow also finishes with a preview capture, which confirms the UI after the build and tests pass.
Interactive diagram. Step through it with the Next and Previous controls below, or Tab to a region to read its detail.
Each pass ends with a screenshot, so the agent checks its change against the rendered UI before the next edit.
How do you set up the Xcode MCP server?
Turn the bridge on in Xcode first, then add the server to Cursor. Cursor's Xcode page lists three prerequisites: macOS with Xcode 26.3 or later, a paid Cursor plan, and Xcode running with a project open. The bridge needs that open project, so start Xcode before you start the agent.
- 1In Xcode, open Xcode > Settings > Intelligence and turn on Xcode Tools under Model Context Protocol.
- 2In Cursor, open Customize > MCPs, click Add New 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 and add a stdio server named
xcode-toolsthat runsxcrun mcpbridge. You can paste the JSON entry into~/.cursor/mcp.jsoninstead. The presenter used a deep-link install, which writes the config intomcp.jsonfor you. - 3Allow the connection when Xcode asks. The presenter clicked through about five allows each time Xcode opened.
- 4If the server won't connect, work through the troubleshooting section of Cursor's Xcode page, then reload Cursor.
- 5If the agent builds with terminal commands instead of 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. tool, reload the bridge with
Cmd+Shift+P→ reload, the presenter's fix.
Each time Xcode opened during the workshop, the bridge needed approving again. Cursor's Xcode docs mention a permission dialog in Xcode that confirms the connection, but they don't say how often it comes back. Plan for a few clicks at the start of each session.
Xcode adds build-and-run plus richer logs, in the presenter's experience: "when you build the app, you're going to get the... build time logs, which is a little bit more hydrated from Xcode versus the build command in the terminal." The presenter's point was that more detailed logs give the agent more to work from when a build fails.
How do you connect Cursor to Android Studio?
The workshop showed three ways, and you can combine them. Option A uses 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.. You install JetBrains' AI Assistant 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., which runs Cursor's agent through the Agent Client ProtocolAn open standard that lets any IDE host any coding agent; Cursor uses it to run inside JetBrains/IntelliJ and Android Studio via the Cursor CLI bridge. Press Enter for the full definition., an open standard for connecting coding agents to IDEs. Cursor's JetBrains page lists two prerequisites: a paid Cursor plan and the AI Assistant plugin. The presenter also installed the Cursor CLICursor's command line: the full agent, all modes and models, in the terminal and pipeable into scripts and CI. Press Enter for the full definition., because in that setup the CLI agent runs the ACP bridge.
- 1Install the JetBrains AI Assistant 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. in Android Studio.
- 2Install the Cursor CLICursor's command line: the full agent, all modes and models, in the terminal and pipeable into scripts and CI. Press Enter for the full definition.. The presenter's setup needs the binary on your machine to run 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. bridge.
- 3Open the AI Chat panel, choose Add Agent from Registry, then find and install Cursor.
- 4Sign in through the side chat or the CLI. In the demo, the CLI sign-in carried over to the IDE.
- 5Pick the model in the CLI. In the demo it carried through to the IDE, along with the agent modes 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. supports.
Option B mirrors the iOS approach with 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. The presenter enabled 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 access, plus a separate debugger MCP server for fine control. As demoed, the debugger server sets line and conditional breakpoints, starts the debugger, and steps in and out, "like anything you would probably do in the UI," as the presenter put it. According to the presenter, turning on "pass to IntelliJ MCP server" also exposes Android Studio's MCP servers to Cursor.
Option C runs 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. servers 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 Cursor agent can call MCP tools from the integrated experience. The presenter called it "all of them combined together." For these servers, the presenter had also built a custom Cursor 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.: one install wires in the MCP client definitions and adds skills that steer the agent toward their tools.
Interactive diagram. Tab through its regions; each focused region shows its detail in the panel below.
Both turn the native IDE into a tool surface for the agent. iOS goes through one server built into Xcode. Android gives you a choice of bridges.
What does the ACP route leave out?
Debug modeA mode that diagnoses a failure: it reproduces the issue, adds instrumentation and watches the logs, rather than reviewing a pull request. Press Enter for the full definition. is the main gap. Through the JetBrains integration, the presenter had ask, agent and plan modes, and debug mode wasn't in 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. spec yet. Cursor's CLI docs list the same three modes for ACP sessions. For debug mode, use the CLI or the 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.. The presenter expected Cursor to add debug to ACP once the spec does.
JetBrains' implementation showed an oddity in the demo: after the agent wrote a plan, there was no button to build it. In the presenter's words, "you have to switch to agent and then tell it to build the plan. That's like one example of a kind of oddity of how JetBrains implemented 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.."
Rough edges like this are why the presenter prefers the sidecar. In the presenter's view, the in-IDE chat is convenient, but the CLI and the 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. give you every mode and richer output.
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. also reaches beyond Android. The presenter pointed to open-source ACP work for Neovim and Emacs, and to integrations in non-coding tools such as Obsidian, where Cursor's agent can sit in your note editor while you write. The presenter described ACP as the way Cursor's agent travels between tools, and said Cursor would keep up with the spec as it changes.
Which model should you use for mobile MCP work?
Use an execution model, not a high-reasoning one, when a task makes many 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. tool calls. That was the presenter's rule for keeping spend under control. A mobile loop fires call after call (build, run, screenshot, read logs, repeat), and in the presenter's account a high-reasoning model burns tokens between calls while it waits for each result.
"Whenever you're using heavy 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. tool calling for a task or a prompt, don't use a high reasoning model... Don't use a heavy Opus high thinking, use Composer 2Cursor's own coding model, built on the open Kimi K2.5 base as a software-engineering specialist. Cursor calls it frontier-level at coding and more cost-efficient than comparable models; Composer 2.5 has since replaced it in Cursor's model list. Press Enter for the full definition., Composer 2 Fast, more of an execution model, which can keep the spend more under control versus burning tokens calling functions..."
Cursor's models page now lists Composer 2.5The current Composer release, better at long-running tasks and at judging when a job needs a light touch versus deep work. Press Enter for the full definition. and Composer 2.5 (Fast) in place of the Composer 2Cursor's own coding model, built on the open Kimi K2.5 base as a software-engineering specialist. Cursor calls it frontier-level at coding and more cost-efficient than comparable models; Composer 2.5 has since replaced it in Cursor's model list. Press Enter for the full definition. models the presenter named. The Composer 2.5 page describes the model as tuned for tool use, file edits and terminal operations inside Cursor.
The presenter made two more points about models. Agent modes set the direction of the work, and the model sets its speed. Providers also have downtime, so when one is degraded, switch models or use Auto, which the presenter said weighs model availability when it picks a model. Check your plan before you count on Auto: Plus doesn't include it, and Cursor's plan list gives Free only Agent and Chat.
What about React Native and Flutter?
React Native with Expo was the smoother integration in the presenter's view. Run the Expo server and it hot-reloads your changes, so you skip the build-and-run step that the Xcode and Android bridges exist to handle. The presenter's rule of thumb: if your framework already gives you fast hot reload, you don't need the heavier native 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. loop.
On native iOS, the agent could bring up the simulator and take screenshots, but it couldn't click around inside the simulator to drive flows. To test behavior, the presenter's advice was to write traditional unit tests through Cursor and leave running the simulator to Xcode.
Flutter and embedded targets were outside the presenter's depth, and the advice there was the same 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. or 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 pattern. For remote or embedded work over SSH, the presenter said SSH in the 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. had been updated to work better for remote development than the editor.
According to the presenter, Cursor was exploring iOS and Android simulators inside Cloud AgentsAgents that run in a Cursor-managed virtual machine, check out the repo, do the work and open a pull request, then shut down, with no load on your laptop. Press Enter for the full definition., for a deeper integration than 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. bridge between apps. Because Android is Linux-based, a team member had already gotten a Cloud Agent to run an Android simulator, with a lot of instructions. A version without that hand-holding hadn't rolled out and had no date. Cursor's Cloud Agent docs don't mention simulators.
Should mobile build profiles be skills or rules?
Use skills for build profiles such as iOS preview, development and production, the presenter recommends. A rule can tell the agent to use a certain profile, but in the presenter's experience the agent may or may not follow that guidance. A skill, in the presenter's words, is "a definitive workflow that the agent will definitely run through."
The presenter's rule of thumb: when you want a procedure followed the same way every time, write a skill.
- Primitive
- Rule
- Who invokes it
- Included as guidance when it applies
- Best for on mobile
- Soft conventions: code style, preferred libraries
- Primitive
- Skill
- Who invokes it
- The agent, when it judges the skill relevant; you can also type a slash and its name
- Best for on mobile
- Fixed workflows: refresh-and-run, a specific build profile, debugging with 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.
- Primitive
- Command
- Who invokes it
- You, manually (slash + name)
- Best for on mobile
- On-demand actions you trigger yourself
- Primitive
- Plugin
- Who invokes it
- You, by installing the bundle
- Best for on mobile
- Packaging 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. servers and steering skills for a team
| Primitive | Who invokes it | Best for on mobile |
|---|---|---|
| Rule | Included as guidance when it applies | Soft conventions: code style, preferred libraries |
| Skill | The agent, when it judges the skill relevant; you can also type a slash and its name | Fixed workflows: refresh-and-run, a specific build profile, debugging with 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. |
| Command | You, manually (slash + name) | On-demand actions you trigger yourself |
| Plugin | You, by installing the bundle | Packaging 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. servers and steering skills for a team |
Skills load through what the presenter called progressive disclosureHow skills load: the agent boots knowing only each skill's name and description, then pulls a skill's full instructions into context only at the moment it decides to use it. Press Enter for the full definition.. In the presenter's description, the agent starts with the name and description of every skill, picks a moment to pull one in while it works, and only then loads the rest of that skill's file. Cursor's skills docs describe the same behavior more briefly: the agent decides when a skill is relevant, and skills load resources on demand. So a refresh-and-run skill, or one that drives debug mode through 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. tools, can make a mobile loop repeatable.
Asked about App Store and Play Store rules (code transparency, user safety, native permission policies), the presenter said nothing covers them out of the box. The suggestion was a 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. of skills and rules that steer the agent toward those policies and check the code as it lands, which still takes manual work to build.
Frequently asked questions
Can Cursor run the iOS simulator?
Partly. With Xcode 26.3 or later, Xcode's built-in MCP server lets Cursor's agent build, run tests, read build logs and capture screenshots. The workshop presenter described screenshots of the running simulator, while Cursor's Xcode docs describe screenshots of a SwiftUI preview. In the workshop, the agent couldn't click around inside the simulator, so test behavior with unit tests.
How do I use Cursor with Android Studio?
The mobile workshop showed three ways. Run Cursor's agent over the Agent Client Protocol through JetBrains' AI Assistant plugin, add IntelliJ MCP server plugins (including a debugger MCP) to mirror the Xcode setup, or combine both so the agent calls MCP tools inside the ACP chat. Cursor's JetBrains docs list a paid Cursor plan as a prerequisite for the ACP route.
Why does Xcode keep asking me to allow the connection?
Xcode shows a permission dialog to confirm the MCP bridge connection. The workshop presenter clicked through about five allows each time Xcode opened, so expect them every session. If the bridge still won't connect, follow the troubleshooting section of Cursor's Xcode docs and reload Cursor.
Which model is cheapest for mobile work in Cursor?
The workshop presenter's rule is to use an execution model for heavy MCP tool calling, not a high-reasoning model, which spends tokens while it waits on each tool result. The workshop named Composer 2 and Composer 2 Fast, and Cursor's models page now lists Composer 2.5 and Composer 2.5 (Fast) instead.
Is React Native easier than native iOS/Android in Cursor?
In the workshop presenter's view, yes. With Expo you run the Expo server, which hot-reloads changes, so you skip the build-and-run step that the Xcode and Android bridges exist to handle.
Should I use a rule or a skill for iOS build profiles?
The workshop presenter recommends a skill per profile. In the presenter's view, a rule is guidance the agent may not follow, while a skill is a workflow it runs through. Cursor's skills docs add that the agent decides when a skill is relevant, and you can also run one yourself by typing a slash and its name.
Sources & last verified
- Cursor: Agent (modes and the Agents window)
- Cursor: Model Context Protocol (MCP)
- Cursor CLI
- Cursor: Models
- Cursor: Xcode integration
- Cursor: JetBrains (ACP)
- Cursor CLI: ACP
- Cursor: Agents Window
- Cursor: Agent Skills
- Cursor: Composer 2.5
Cursor ships frequently. Last updated October 28, 2026.