Cursor Launches iOS App for AI-Powered Development On the Go

Cursor shipped something I've wanted for two years: a real native iOS agent runner, not a chat client in a phone-shaped wrapper. The Cursor for iOS public beta launches always-on agents in the cloud, controls agents already running on your local machine, and moves work between the two with a single handoff. It is the first mobile AI tool I've used that treats the phone as a control surface for an autonomous worker — not a place to paste prompts and squint at a log.

That's worth pausing on, because most "AI mobile apps" are read-only dashboards over a web app. Cursor's iOS build does four things that put it in a different category: it picks a repo and launches an agent, it steers the agent with voice and slash commands, it pings you back on the lock screen when the work is ready, and it lets you hand the same task off to a cloud VM and back to your laptop without losing context.

What the Cursor iOS app actually is

The app is a native iOS client, currently in public beta. You log in, pick a repository the same way you would on the desktop, and launch an agent against it. The app supports the same frontier models the desktop client does, so you're not stuck with a phone-tier model. You steer the agent with two interfaces that map cleanly to a phone: voice input for describing the idea, and slash commands for the precise bits — the same slash commands you already use on desktop.

For agents already running on your laptop, the Remote Control feature lets the phone keep steering them. A toggle in the app keeps your computer awake so the local agent stays reachable while you're out. When the agent finishes, needs input, or has a diff ready for review, you get a push notification. Live Activities on the lock screen show the same state without enabling the phone.

The part most coverage will skip is the handoff. Cursor's cloud agents run in isolated virtual machines with a full development environment — their own tools, their own resources, their own network. They work asynchronously on longer tasks and iterate toward merge-ready pull requests. You can send a local plan to a cloud agent, move an active agent from your laptop to the cloud so it keeps running after you put the phone down, and bring the cloud session back to your computer to test changes locally before merging.

How to use it today

The app is in public beta. Here's the actual workflow, not the marketing version.

# 1. Install
# App Store → "Cursor" → install → sign in with your existing account
# Your repos and billing carry over from the desktop client

Launching a task is the same shape as desktop, just on a phone:

[ Pick repo ]  →  [ Pick model ]  →  [ Describe task via voice or type ]

Slash commands behave the same as on desktop, so any commands you've already wired into the desktop client carry over. The voice input is the new bit, and it's the part that makes the phone form factor work — typing a 200-character spec on a glass slab is where every other "AI mobile" app dies.

The on-call flow is the one Cursor is clearly optimising for, and it shows. You're paged at 7pm. Instead of opening a laptop, you:

1. Open Cursor on the iPhone
2. Pick the repo and the failing service
3. Tell the agent, in plain speech, what's broken and what the error looks like
4. Hand the plan off to a cloud agent so it can keep working after you put the phone down
5. Get a Live Activity + push notification when the PR is ready
6. Inspect the diff, leave a follow-up if needed, merge

The annotation flow is the other one worth knowing. If a customer sends a screenshot of a bug, you pull it into the app, draw on it, and send the annotated image to the agent as visual context for design or UI changes. The agent treats your marks as the spec, not just the picture. That's a real product decision, not a gimmick — it changes what "describe a UI change" means.

What this enables for builders

The interesting downstream effect isn't "you can use AI on the train." It's that the bottleneck for async engineering has shifted. If the agent can run for an hour, return a merge-ready PR, and only interrupt you on the lock screen for review, then the cost of starting a task collapses. You stop asking "is this worth opening my laptop for?" and start asking "is this worth a voice command on the way out the door?"

Three workflows become genuinely first-class on a phone:

• On-call incidents. The annotated-screenshot-to-agent pipeline is the first mobile incident response that doesn't feel like a workaround. You stop booting a laptop at midnight for things a phone can resolve.
• Customer feedback loops. Pull a screenshot from any app, annotate, send. The agent gets visual context, not just text, and ships a PR to the right component. The "acting on feedback from other mobile apps" workflow Cursor calls out is the first time this loop closes without a human in the middle.
• Async design handoff. Describe a UI change in voice, mark up the screenshot, hand off. The cloud agent iterates while you're in a meeting. Review the diff, merge, or send back with a follow-up — all from the phone, or pick it up on the laptop later.

The part that doesn't change when the agent does

Here is the thing worth saying out loud: the agent runner will keep changing. Cursor shipped cloud + local handoffs in this beta; next quarter they'll add multi-agent orchestration, deeper MCP integrations, browser sub-agents, who knows what. The model behind it will churn. The phone will get more features. The control surface will keep moving.

What doesn't move is the screen the agent has to ship into. If your agent produces a component for a dashboard, that component has to render correctly on a web app, an iOS app, and an Android app, and it has to behave the same in all three. That is the layer the agent cannot reason its way out of. The agent will happily hand you a card built for the web, and your iOS and Android builds will start to drift the moment you accept it.

That is the durable layer underneath the tool churn. One component spec, one API, the same look and behaviour on web, iOS, and Android — without re-implementing the screen for each platform. The agent runs the work; the cross-platform layer decides where the work lands. The two compose: use Cursor for iOS to launch and steer the agent, use a real cross-platform component layer to make sure what comes back actually ships to all three surfaces.

That is the split worth understanding. The tool churn is fun and worth using. The platform layer underneath it is the part that pays off across every model release, every agent runner update, and every phone feature Cursor adds next.