# Cursor Push-Benachrichtigungen: ein Ping, wenn der Agent fertig ist

> Erhalte eine Push-Benachrichtigung aufs Handy, wenn ein Cursor-Agent fertig ist, fehlschlägt oder dir etwas mitteilen möchte. Ein Stop-Hook für jeden Lauf, dazu der Pocket Alert MCP-Server für Nachrichten, die der Agent selbst schreibt.

*12.10.2026*

<!-- source: https://pocketalert.app/de/blog/cursor-push-notifications -->

Cursors Agent kann ein Modul umbauen, während du Kaffee kochst. Bei einem gewöhnlichen lokalen Lauf meldet Cursor aber das Ende nur auf dem Computer: mit einem Ton oder einer Systembenachrichtigung, falls du sie aktiviert hast. Die Cursor-iOS-App sendet eine Push-Benachrichtigung, wenn ein Agent eine Runde beendet, allerdings nur für Cloud-Agents und Sitzungen, die du per Remote Control übergibst, und nur mit einem kostenpflichtigen Tarif und einem iPhone. Android ist geplant.

Wenn du eine Push-Benachrichtigung aufs Handy willst, sobald ein lokaler Agent-Lauf endet, bietet Cursor dafür zwei Wege:

- **Ein `stop`-Hook.** Cursor führt dein Skript jedes Mal aus, wenn die Agent-Schleife endet, ob erfolgreich, abgebrochen oder mit einem Fehler. Zuverlässig und immer gleich.
- **Ein MCP-Tool.** Füge den Pocket Alert MCP-Server hinzu, dann kann der Agent dir immer dann eine Push-Nachricht senden, wenn du ihn darum bittest, mit einem Text, den er selbst schreibt.

Diese Anleitung richtet beides ein. Jeder Weg dauert ein paar Minuten.

## Was du brauchst

- Cursor 1.7 oder neuer; Hooks gibt es seit Version 1.7.
- `jq` und `curl` für den Hook.
- Ein Pocket Alert-Konto, einen API-Schlüssel von [API-Schlüssel](/account/apikeys) und die [App](/get-app) auf deinem Handy. Der kostenlose Tarif reicht.

Cursor, das über das Dock gestartet wird, liest deine `.zshrc` nicht. Umgebungsvariablen, die du dort exportierst, sind für Cursor daher unsichtbar. Speichere den Schlüssel deshalb in einer Datei:

```bash
mkdir -p ~/.config/pocketalert
printf '%s' 'YOUR_API_KEY' > ~/.config/pocketalert/key
chmod 600 ~/.config/pocketalert/key
```

## Option 1. Ein Stop-Hook für jeden Lauf

### Das Skript

Cursor übergibt dem Hook ein JSON-Objekt über stdin. Bei `stop` enthält es `status` (`completed`, `aborted` oder `error`) und `workspace_roots`, die Ordner, die im Fenster geöffnet sind. Speichere dies als `~/.cursor/hooks/pocketalert.sh`:

```bash
#!/usr/bin/env bash
payload=$(cat)
project=$(basename "$(jq -r '.workspace_roots[0] // "cursor"' <<<"$payload")")
status=$(jq -r '.status // "completed"' <<<"$payload")

case "$status" in
  completed) title="Cursor finished · $project"; level=default ;;
  error)     title="Cursor hit an error · $project"; level=high ;;
  *)         echo '{}'; exit 0 ;;
esac

jq -n --arg t "$title" --arg m "Agent run $status" --arg l "$level" \
  '{title: $t, message: $m, level: $l}' |
  curl -sS --max-time 5 https://api.pocketalert.app/v1/messages \
    -H "Token: $(cat ~/.config/pocketalert/key)" \
    -H 'Content-Type: application/json' \
    --data-binary @- >/dev/null 2>&1 || true

echo '{}'
```

```bash
chmod +x ~/.cursor/hooks/pocketalert.sh
```

Abgebrochene Läufe werden absichtlich übersprungen: Wenn du auf Stopp gedrückt hast, weißt du das bereits. Das Skript gibt `{}` aus, weil ein `stop`-Hook eine `followup_message` zurückgeben kann, die Cursor als deinen nächsten Prompt an den Agenten schickt. Ein leeres Objekt bedeutet „nichts hinzuzufügen“.

### Oder mit der Pocket Alert CLI

Wenn die [Pocket Alert CLI](/tools/cli) in Version 2.0 oder neuer installiert ist, schrumpft der curl-Block auf einen Befehl. Die CLI maskiert den Text selbst und liest den Schlüssel aus `pocketalert auth`:

```bash
pocketalert send -t "$title" -m "Agent run $status" -l "$level" -q >/dev/null 2>&1 || true
```

Verwende `-t` und `-m` statt Positionsargumenten: Eine Antwort, die mit einem Bindestrich beginnt, etwa eine Markdown-Liste, würde sonst als Option gelesen.

### Registrieren

Erstelle `~/.cursor/hooks.json`:

```json
{
  "version": 1,
  "hooks": {
    "stop": [
      { "command": "/Users/you/.cursor/hooks/pocketalert.sh", "timeout": 10 }
    ]
  }
}
```

Verwende den absoluten Pfad zum Skript und ersetze `/Users/you` durch dein Home-Verzeichnis. Die Datei im Home-Ordner gilt für jedes Projekt. Soll sie nur für ein Projekt gelten, lege sie als `.cursor/hooks.json` im Repository ab.

Cursor lädt `hooks.json` von selbst neu, wenn sich die Datei ändert. Gib dem Agenten eine kleine Aufgabe, und wenn er fertig ist, zeigt dein Handy **Cursor finished · dein-projekt** an.

### Die Antwort des Agenten in der Push-Nachricht?

`stop` enthält die Antwort des Agenten nicht, `afterAgentResponse` aber schon, als `text`. Wenn du statt nur des Status die ersten Zeilen der Antwort pushen möchtest, registriere dasselbe Skript für `afterAgentResponse` und lies `.text` von stdin. Es wird nach jeder Antwort ausgelöst und ist daher lauter. Die meisten Leute behalten deshalb `stop`.

## Option 2. Der MCP-Server

Der Hook sagt dir, dass ein Lauf beendet ist. Der MCP-Server lässt den Agenten dir erzählen, was passiert ist. Füge Pocket Alert zu `~/.cursor/mcp.json` hinzu:

```json
{
  "mcpServers": {
    "pocketalert": {
      "url": "https://mcp.pocketalert.app/mcp",
      "headers": { "Authorization": "Bearer YOUR_API_KEY" }
    }
  }
}
```

Der Schlüssel steht wegen des oben beschriebenen Dock-Problems direkt in der Datei. Diese Datei liegt in deinem Home-Ordner, nicht in einem Repository. Wenn du Cursor aus einem Terminal startest, in dem der Schlüssel exportiert ist, funktioniert stattdessen `"Bearer ${env:POCKETALERT_API_KEY}"`.

Öffne den MCP-Bereich der Cursor-Einstellungen, prüfe, ob `pocketalert` seine Tools anzeigt, und frage:

```text
> Run the test suite. When it's done, push me the number of failures with Pocket Alert.
```

Der Agent ruft `create_message` mit einer Zusammenfassung auf, die er selbst geschrieben hat. Er kann auch `level` setzen, sodass eine fehlgeschlagene Testsuite als `high` ankommt, und auf einem kostenpflichtigen Tarif Aktionsbuttons anhängen.

Damit daraus eine Gewohnheit wird und nicht jedes Mal eine eigene Anweisung nötig ist, füge eine Projektregel hinzu:

```text
When a task takes more than a few minutes, finish by calling the pocketalert
create_message tool with a one-line summary. Use level "high" if anything failed.
```

## Welchen Weg wählen

<div class="cmp-table-wrap">
<table class="cmp-table">
<thead><tr><th></th><th>Stop-Hook</th><th>MCP-Tool</th></tr></thead>
<tbody>
<tr><th>Wird ausgelöst</th><td>Bei jedem Lauf, immer</td><td>Wenn der Agent es entscheidet</td></tr>
<tr><th>Nachricht</th><td>Status: completed oder error</td><td>Was der Agent schreibt</td></tr>
<tr><th>Benötigt</th><td>Ein Skript und <code>hooks.json</code></td><td>Ein Block in <code>mcp.json</code></td></tr>
<tr><th>Kann still fehlschlagen</th><td>Nur bei Netzwerkausfall</td><td>Wenn das Modell es vergisst</td></tr>
</tbody>
</table>
</div>

Beides zusammen ist ein guter Standard: Der Hook garantiert, dass du von jedem Lauf erfährst, das MCP-Tool liefert den Inhalt, wenn es darauf ankommt.

## Freigaben

Cursor hat keinen Hook für „der Agent wartet auf eine Freigabe“. `beforeShellExecution` und `preToolUse` werden vor jedem Befehl ausgelöst, auch vor denen, die Cursor ohne Nachfrage ausführt. Damit lässt sich also nicht erkennen, wann du tatsächlich gebraucht wirst. Für diesen Fall bieten heute Cursors eigene Desktop-Benachrichtigungen und die iOS-App eine Lösung.

Wenn der Agent vor einem riskanten Schritt anhalten und nachfragen soll, gib ihm das MCP-Tool und eine Regel, die eine Push-Benachrichtigung mit den Buttons Genehmigen und Ablehnen sendet. [Human-in-the-loop-Benachrichtigungen](/blog/human-in-the-loop-notifications) zeigt, wie daraus eine echte Sperre wird statt einer höflichen Bitte.

## Wenn nichts ankommt

- **Skript von Hand ausführen:** `echo '{"status":"completed","workspace_roots":["/tmp/demo"]}' | ~/.cursor/hooks/pocketalert.sh`. Kommt keine Push-Benachrichtigung an, entferne `>/dev/null 2>&1`, um die curl-Fehlermeldung zu sehen.
- **Cursor neu starten**, falls der Hook trotzdem nicht läuft. Normalerweise lädt Cursor `hooks.json` von selbst neu, wenn sich die Datei ändert.
- **Pfad prüfen:** Der Pfad in `hooks.json` muss absolut sein, und das Skript muss ausführbar sein.
- **Bei MCP die Tool-Liste prüfen.** Eine Fehlermeldung neben dem Server in den MCP-Einstellungen von Cursor bedeutet meist, dass der Schlüssel falsch oder leer ist.

## FAQ

### Hat Cursor Push-Benachrichtigungen eingebaut?

Auf dem Computer ja: einen Abschlusston und Systembenachrichtigungen. Aufs Handy sendet die Cursor-iOS-App eine Push-Benachrichtigung, wenn ein Cloud-Agent oder eine Sitzung, die du per Remote Control übergibst, eine Runde beendet. Dafür braucht es einen kostenpflichtigen Tarif und ein iPhone. Gewöhnliche lokale Läufe bleiben am Computer, und genau dafür ist die Einrichtung hier gedacht.

### Funktioniert das auch für Hintergrund- und Cloud-Agents?

Der Hook in `~/.cursor/hooks.json` läuft nur auf deinem Rechner und deckt daher lokal laufende Agents ab. Cloud-Agents laufen auf Cursors Servern: Sie führen Projekt-Hooks aus der `.cursor/hooks.json` des Repositorys aus, aber keine Benutzer-Hooks, und die Schlüsseldatei ist dort nicht vorhanden. Dafür funktioniert der MCP-Weg, wenn der Agent den Server konfiguriert hat, oder du nutzt die iOS-App von Cursor oder die Slack-Integration.

### Sieht der Agent meinen API-Schlüssel?

Im Hook-Setup nicht: Der Schlüssel bleibt in einer Datei, die nur das Skript liest. Beim MCP-Setup liegt der Schlüssel in der Konfiguration von Cursor und wird an den MCP-Server gesendet, nicht an das Modell.

### Ist es kostenlos?

Ja. Hooks und MCP sind Teil von Cursor, und der kostenlose Tarif von Pocket Alert umfasst 50 Nachrichten am Tag auf einem Gerät.

[API-Schlüssel holen](/signup), den Hook einrichten und dir von Cursor sagen lassen, wann es fertig ist.
