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 look at what you run, decide what needs watching and set it up: monitors, alert destinations, routing and status pages, in one conversation.
Add https://mcp.lastping.dev/mcp and sign in to LastPing; Windsurf uses an API key. Watching an AI agent's own runs? That is AI agent monitoring.
Three steps
Connect
Add
https://mcp.lastping.dev/mcpto your AI client: the steps for each client.Sign in, or use a key
Sign in to LastPing in the browser that opens. Windsurf uses an API key.
-
Ask your assistant
- Look at the cron jobs and scheduled workflows in this repository and set up a LastPing monitor for each one.
- Which of my monitors failed in the last 24 hours, and why?
- Create a monitor for my nightly backup that runs at 02:00 UTC and alert me by email if it is late.
More in the prompt cookbook.
Connect your client: sign in
The server speaks Model Context Protocol over Streamable HTTP. Add the URL, sign in to LastPing in the browser and choose read and write or read only. There is no key to copy or keep.
With the set-up skill
npx skills add lastping-dev/skills- Ask:
Monitor this project with LastPing
You sign in once. Or connect by hand: the steps below.
Claude apps (claude.ai, Desktop, mobile, Cowork)
- Open LastPing in the Claude Connectors Directory (https://claude.ai/directory/lastping), or search for LastPing under Settings, Connectors, Discover.
- Press Connect, sign in to LastPing and allow the connection.
- 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/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/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)
- 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.
- Open Plugins, press + and create an app: name it LastPing, paste
https://mcp.lastping.dev/mcpand choose OAuth. - Sign in to LastPing and allow the connection.
- 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/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/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/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/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 connects with a key. Every other client except ChatGPT and the Claude web, mobile and Cowork apps can too. Create one at app.lastping.dev, Settings, API keys, and put it where the snippet says lp_your_key. A 401 means the key is wrong, revoked or expired: create a new one, replace it and restart the client.
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/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/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/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.
- Download lastping.mcpb.
- Double-click it; Claude Desktop opens its install dialog.
- 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/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/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/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/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/mcp
In agy, /mcp then shows lastping.
The MCP tool surface
50 MCP tools, each implemented in github.com/lastping-dev/lastping-app and shipped in both the hosted server and the stdio binary. Smithery and the official MCP registry connect to it and enumerate these tools themselves.
Monitors
create_monitorlist_monitorsget_monitorupdate_monitordelete_monitorpause_monitorresume_monitorsnooze_monitor
Upsert by slug (heartbeat, ci, http), so an agent can retry safely. Pause stops alerting; snooze sets a maintenance window.
Incidents and runs
list_incidentsget_incidentget_run_historyget_runlist_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_incidentsadd_incident_note
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_destinationscreate_destinationupdate_destinationtest_destinationdelete_destination
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_routedelete_routelist_deliveries
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_pagescreate_status_pageupdate_status_pagedelete_status_pageget_alert_templatesset_alert_template
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_keylist_api_keysregenerate_api_keyrevoke_api_key
Scopes read, write, admin or ingest. The plaintext is returned once; a list shows only the prefix.
Tracing
get_trace_setupcreate_ingest_keyget_trace_diagnostics
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_agentlist_agentsget_agentupdate_agentdelete_agentget_agent_dependenciesget_agent_usagelist_dependencieslist_discovered_agentsadopt_discovered_agent
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_instructionsdeclare_run_expectationsdiscover_monitors_reconcileexport_terraform
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.
Ping and trace endpoints
GET https://ping.lastping.dev/<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/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
Without lastping.run_id each trace becomes a run of its own. A request is capped at 1 MiB decompressed and 500 spans, a run at 2,000 spans. lastping run sets the endpoint, header and ids for the command it wraps when LASTPING_API_KEY is set.
One conversation. The agent instruments itself.
When the assistant is itself an agent that runs unattended, it creates the monitor and wires in the pings. Three tool calls, no dashboard.
Create the monitor
create_monitorwith a stableslug, so a re-run upserts instead of duplicating.Get ping snippets
get_ping_instructionsreturns ready-to-runcurl_success,curl_start,curl_failandcurl_stepcommands.Wire pings into the work
Start at launch, success at the end, fail on any error path. Step pings alert only if the monitor sets
step_timeout_s, and a step never extends the run budget.
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/<id>get_ping_instructions({ "id": "<monitor-uuid>" })
โ {
"curl_success": "curl -fsS -m 10 --retry 3 -o /dev/null https://ping.lastping.dev/<id>",
"curl_start": "curl -fsS -m 10 --retry 3 -o /dev/null https://ping.lastping.dev/<id>/start",
"curl_fail": "curl -fsS -m 10 --retry 3 -o /dev/null https://ping.lastping.dev/<id>/fail",
"curl_step": "curl -fsS -m 10 --retry 3 -o /dev/null \"https://ping.lastping.dev/<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 detailHow the agent reports
get_ping_instructions returns reporting_options, a rule for how to report (chosen by what the agent is, not ranked), plus the manual curl_success / curl_start / curl_fail / curl_step snippets, run_wrapper and hook_install, a hook install for Claude Code, Codex or Antigravity CLI; the Claude Code install is the only one that sends every state, including blocked and note.
# 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
Monitors an agent creates over MCP are real but invisible to the repo. export_terraform renders what exists as HCL, pairs every resource with an import block, and hands it back for the agent to commit.
- Secrets are never in the output: each credential becomes a
var.reference with asensitive = truevariable. - The same export from
GET /api/v1/export/terraformor Export as Terraform in the app. - Then it is ordinary Terraform, with the official
lastping-dev/lastpingprovider. Agent-readable: terraform.md.
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: ask your agent
These work once LastPing MCP is connected. Paste as-is or adapt.
"Monitor my nightly Postgres backup and alert me on Telegram if it doesn't check in by 3am."
create_monitorcreate_destinationtest_destinationset_routeget_ping_instructions
"Add a LastPing dead-man's-switch to the deploy pipeline you just wrote, daily at midnight, 30-minute grace."
create_monitorget_ping_instructions
"Create a monitor for this nightly summary agent, runs at 2am UTC, alert me on Slack if it goes silent or fails."
create_monitorcreate_destinationtest_destinationset_routeget_ping_instructions
"Check all my monitors. Which ones have had incidents in the past week?"
list_monitorslist_incidents
"Snooze the nightly-backup monitor for 4 hours while I run a maintenance window."
list_monitorssnooze_monitor
"Set up a LastPing HTTP uptime monitor for api.example.com, probing every 60 seconds."
create_monitor
"Create a webhook destination for my on-call endpoint and route the production-deploy monitor's down and fail events to it."
list_monitorscreate_destinationtest_destinationset_route
"Instrument yourself: register a heartbeat for this agent at '0 6 * * *' (6am daily, 45-minute grace), get the ping snippets, and add them to your run loop."
create_monitorget_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) and LASTPING_PING_HOST (default https://ping.lastping.dev).
# 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/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/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/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/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/<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.