Cursor Push Notifications: Get Pinged on Your iPhone When the Agent Finishes

You kick off a big refactor in Cursor's agent mode, watch it churn for a minute, then switch to Slack "just for a sec." Forty minutes later you tab back, and the agent has been done since minute three, sitting on a follow-up question you never saw.

That gap between "the agent finished" and "you noticed" is dead time. Cursor will happily grind through a twenty-file migration in the background, but it can't lean over and tap your shoulder when it's done, so you keep checking the tab every few minutes, which is the exact babysitting the agent was supposed to save you from.

Background agents make this worse, not better. The whole point of handing Cursor a task and walking away is that you're not watching, which is exactly when a silent "done" is easiest to miss. The editor knows the run ended. Your pocket doesn't, unless you tell it to.

Cursor speaks MCP, and TheNotificationApp ships an MCP server. Wire the two together and Cursor sends a push straight to your iPhone the moment it's done, or the moment it's stuck and needs you. Here's the five-minute version.

What you'll need

• Cursor, any recent version with MCP support.
• The free TheNotificationApp iOS app, signed in with Apple.
• Two minutes to edit one JSON file.

No SDK, no API key to paste, no server to keep running. The whole integration is a URL and a Sign in with Apple prompt.

Step 1: Add the MCP server to Cursor

Cursor reads MCP servers from a file called mcp.json. Put it at ~/.cursor/mcp.json to make the server available in every project, or drop it in .cursor/mcp.json inside a single repo if you only want it there.

{
  "mcpServers": {
    "thenotification": {
      "url": "https://thenotification.app/api/mcp"
    }
  }
}

That's the entire config. TheNotificationApp's server is remote and streams over HTTP, so Cursor only needs the url. There's no command to run and nothing to install locally. You can also add it from Cursor Settings under MCP if you'd rather click than edit a file; it writes the same block.

Step 2: Sign in with Apple (no API keys)

Open Cursor Settings, find the server under MCP, and hit connect. Cursor kicks off an OAuth flow and TheNotificationApp handles it with Sign in with Apple, no key to generate, copy, or accidentally commit. You get short-lived tokens scoped to your Apple ID instead of a long-lived secret sitting in a dotfile.

Once it connects, Cursor lists the server's tools: a send-notification tool plus list_applications for grabbing an app ID when you've set up more than one. Green dot means you're live.

Step 3: Tell the agent to ping you

Now just ask. In the agent chat, end your instructions with a plain-English line:

When you finish, send me a push notification with a one-line summary of what changed.

Cursor calls the tool and your phone buzzes with whatever title and body the agent wrote. Want it every time without repeating yourself? Drop it in a Cursor rule so it applies to every agent run in the project:

When you finish a task or need my input to continue,
send a push notification. Title = the repo name,
body = one line on what happened or what you need.

The tool takes the same fields as the REST API: title, body, and optional link and image. Set link to a pull request URL and tapping the notification jumps straight there.

Good triggers, noisy triggers

The tool is only as useful as what you point it at. A few triggers that earn their buzz:

• The agent finished a long run: the headline use case. Anything over a couple of minutes is worth a ping.
• The agent needs a decision: it hit an ambiguous choice and stopped. This one saves the most time, because a waiting agent costs you nothing but attention.
• The test suite went red: pass the failing test name in the body so you know whether to hurry back.
• A background agent opened a PR: set the link to the PR and review it from your phone.

And a couple that'll just train you to ignore your phone: every file edit, every tool call, "starting task." If it fires more than a handful of times an hour, it's noise, and noise is how good alerts go unread.

Prefer a script? The curl fallback

MCP is the hands-off route, but if you'd rather fire the notification from a terminal task or a git hook, the plain HTTP endpoint is one POST:

curl -X POST https://thenotification.app/api/sendNotification \
  -H "app_key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"title":"Cursor run done","body":"Tests pass, build is green."}'

A success comes back as {"success": true, "message": "Notification sent to 1 device(s)"}. The full field list and status codes live in the API reference. If you already set this up for Claude, it's the same server, the Claude MCP walkthrough covers the connector side in more detail.

Real talk

Fair warning on the free tier: it's 100 notifications total, not per month: a lifetime bucket across up to 3 apps. That's plenty for "ping me when the big agent runs finish," but if you wire it to fire on every tiny task the agent completes, you'll drain it in an afternoon. Keep the trigger on "done" or "needs me," not on every step. If you outgrow it, Pro is $2.99/month for 1,000 notifications a month.

That's it

Set it once and Cursor stops being something you babysit. Kick off the run, close the laptop lid, go make coffee: your phone tells you when it's your turn again. Worth a look if you're tired of tabbing back to a finished agent. Grab the app and point Cursor at it.

New to this? Start with what an MCP server is.