Code on the go: Cursor launches AI-powered iOS app for developers

The half-open laptop era just endedCopy Anchor Link

Cursor put an AI coding agent in your pocket. That sentence is more interesting than it sounds.

For years, the unofficial SLA for background coding work was a half-shut laptop on a kitchen counter, fans whirring, a coffee ring forming on the spacebar, so an agent could keep running while you made dinner. Cursor's new iPhone and iPad app kills that ritual. You launch an agent in the cloud, walk the dog, and check on it from the bus. The agent keeps going because it is not on your laptop anymore. Your laptop does not need to be awake.

That is the actual headline. Not AI on iPhone. Cloud-resident coding agents you can poke from anywhere, with a native iOS UI in front of them. Anysphere shipped it as a public beta, and the launch coverage confirms the core facts: a public beta with cloud agents, a repo and model picker, and voice input as reported by India Today. The same report places the launch weeks after the reported acquisition news, describing it as a reported $60 billion all-stock deal folding Cursor under xAI. Keep the qualifier: it is reported, not confirmed as closed, and this post treats it that way.

Worth celebrating honestly: agents that follow you between devices is a real product surface, and Cursor shipped it before anyone else in the IDE category.

What lands on the iPhone and iPadCopy Anchor Link

The app is intentionally thin on magic and thick on parity with the desktop client. Same repository picker, same model selector, same prompt box, just shrunken for a thumb.

Three pieces actually matter:

1. Cloud-launched agents. Pick a repo, pick a model, describe the task. The agent runs server-side, so the iPhone is a remote control, not a compute host. Your battery stays flat while the agent keeps cooking.

2. Voice prompts and slash commands. You can dictate the prompt instead of typing it. Slash commands layer extra instructions on top, the same way they do in the desktop client. The mobile keyboard was never going to win against dictation for a prompt like refactor this migration to use the new API, so shipping voice on day one was the right call. The launch report specifically calls out voice input as a day-one capability in the same coverage.

3. Remote control for agents already running on your desktop. This is the sleeper feature. If you kicked off a long-running agent on your Mac before you left the house, the iOS app can hand you the wheel mid-run without restarting anything. You steer, it steers, the local agent keeps its context.

That last one is what closes the loop with the half-open laptop workflow. The laptop does not have to stay half-open anymore. You can close it.

Cursor documents its broader workflow integrations under a connect-your-workflow surface covering GitHub, GitLab, Linear, Slack, and others in the Cursor docs. The canonical place to track what ships next on every surface, including mobile, is the Cursor changelog.

The workflow in three movesCopy Anchor Link

If you have used Cursor on desktop, the iOS app will not surprise you. If you have not, here is the mental model:

# 1. Open the app, pick a repo (same auth as desktop)
# 2. Pick a model — same selector as the desktop client
# 3. Describe the task in plain text or by voice
#    /use opus-4.7
#    Migrate auth.ts from the legacy session middleware to the new
#    JWT helper, keep the existing export names, run the test suite.

The agent takes it from there. You can background the app, lock the phone, do whatever. When you come back, the agent diff is waiting. Approve it from the phone, and the change lands. No waiting until you are at a keyboard.

That is the loop, and it is genuinely good. Mobile-first agent UX has been mostly vaporware until now.

How to actually try it todayCopy Anchor Link

The beta is live in the App Store. Here is the shortest path from curious to running an agent on the bus.

# 1. Install
#    Search "Cursor" in the iOS App Store on the phone.

# 2. Sign in with the same account you use on desktop.
#    Same GitHub OAuth, same workspace, same billing.

# 3. Connect a repo the iOS app can reach.
#    Either an existing Cursor workspace (already authorized) or
#    re-authorize GitHub from the mobile app settings.

# 4. Pick a model.
#    The selector mirrors the desktop client — same model ids,
#    same quotas, same bring-your-own-key on Pro plans.

# 5. Launch your first cloud agent.
#    Prompt: "Find every console.log in src/ and replace with the
#             structured logger. Open a PR when done."
#    Background the app. Lock the phone. Go outside.

# 6. Use Remote Control for an in-flight agent.
#    If you have an agent running on desktop, it appears in the
#    iOS sidebar under Active sessions. Tap to attach.

Two things worth knowing up front:

• It is a public beta. Expect rough edges, occasional disconnects, and the occasional model picker spinning forever moment. That is the price of admission for an early build.
• Local-only agents still need a desktop. If you specifically need an agent to read a large monorepo on your laptop SSD for privacy reasons, the iOS app will not help, and that is correct. Cloud agents are an option, not a replacement.

What this enables, and where it hits a ceilingCopy Anchor Link

What it enables, plainly:

• Async coding. Kick off a refactor before a meeting, review the diff after. The laptop half-open tax is gone.
• Demo-able agents. When a stakeholder asks what the AI actually does, you can show them on a phone, in their hand, without lugging a laptop.
• Lower-failure recoveries. Tripped over a power cable mid-agent run. Phone takes over. Coffee on the keyboard. Phone takes over. The blast radius of breaking your workstation just shrank.

Where it hits a wall:

• You are still prompting in English. Voice-to-prompt is great for a five-line instruction. For a 60-line spec with caveats and edge cases, you will want a real keyboard. Cursor knows this. The desktop app is not going anywhere.
• Diff review on a phone screen is honest, not pleasant. Small surgical diffs are fine. Four-hundred-line refactors will make you squint. Use the mobile app to approve the obvious stuff and gate the hairy stuff for desktop review.
• You cannot ship a UI from a phone yet. Cursor can write code anywhere. The thing the code describes, the actual app interface, the cross-platform component, the layout that has to look right on web and iPhone and Android, is still where the bottleneck lives. Cursor's agent can write the code. Whether that code produces the same component on three platforms with one API is a separate engineering decision. If you are weighing that layer, read one codebase that ships to three platforms and the same component on web and mobile before you standardize.

That last gap is the real one. As the agent moves into your pocket, the durable question stops being which IDE ships to which device and becomes what is the layer underneath all of them that does not churn when the IDE does.

The part that does not change when the tool doesCopy Anchor Link

Here is where the OTF angle lands, and it is short because it is not a competitor to Cursor. It is the floor under it.

The new iOS app is a beautiful control plane. It is not a guarantee that the thing your agent builds behaves the same way on a webpage, an iPhone, and an Android tablet. That guarantee has to live in the component layer: one component spec, one API, the same look and behavior on web and on every native shell. When Cursor's model picker changes next quarter, and it will, your shipped product should not have to.

That is the bet OTF is built around. The agent can move to your pocket. The model under the hood can swap. The runtime can be web or native. The thing the user taps should not have to be rewritten for any of that.

If you are turning a weekend agent spike into something shippable, run it through the ship-to-production checklist before you call it done.

Use Cursor from the bus. Run agents from the train. Let the laptop lid stay closed. And ship the surface your agents build on top of a layer that does not care which tool wrote it. Start from production-ready kits your agent can actually ship.

The half-open laptop era ended. The rest of the stack is next.

SourcesCopy Anchor Link

• India Today — Cursor wants developers to code using phone, iOS app arrives — public beta, cloud agents, repo and model picker, voice input, and the reported $60B all-stock deal context.
• Cursor docs — workflow connections — connect-your-workflow surface for GitHub, GitLab, Linear, Slack, and related integrations.
• Cursor changelog — canonical release history for tracking mobile and agent feature updates.