Monitor LangChain: dead-man's-switch for scheduled agent and chain runs

LangChain agents fail silently at the boundary.

LangChain has excellent tracing (LangSmith) for what happens inside a run, but no built-in monitoring for whether the run happened at all, or whether it's currently blocked waiting forever.

Setup: three lines of Python

No LangChain plugin, callback, or middleware needed. Plain HTTP calls bracket the chain invocation.

https://ping.lastping.dev/<uuid>

import requests  # or httpx

PING_URL = "https://ping.lastping.dev/<uuid>"

def run_chain():
    requests.get(f"{PING_URL}/start", timeout=10)  # arm watchdog
    try:
        result = chain.invoke({"input": "Run the weekly digest."})
        requests.get(PING_URL, timeout=10)          # signal success
        return result
    except Exception as exc:
        requests.post(
            f"{PING_URL}/fail",
            data=f"{type(exc).__name__}: {exc}",
            headers={"Content-Type": "text/plain"},
            timeout=10,
        )
        raise

import httpx

async def run_chain_async():
    async with httpx.AsyncClient() as client:
        await client.get(f"{PING_URL}/start", timeout=10)
        try:
            result = await chain.ainvoke({"input": "..."})
            await client.get(PING_URL, timeout=10)
            return result
        except Exception as exc:
            await client.post(
                f"{PING_URL}/fail",
                content=f"{type(exc).__name__}: {exc}",
                headers={"Content-Type": "text/plain"},
            )
            raise

import uuid, requests

rid = uuid.uuid4().hex
requests.get(f"{PING_URL}/start", params={"rid": rid}, timeout=10)

for name, stage in stages:
    stage.invoke(state)
    requests.get(f"{PING_URL}/step",
                 params={"rid": rid, "step": name}, timeout=10)

requests.get(PING_URL, params={"rid": rid}, timeout=10)

What this catches

Orthogonal to LangSmith tracing: catches the failure modes that happen outside the chain's execution boundary.

• ✓Missed scheduled runs: scheduler crash, OOM kill, cron misconfiguration. No start ping in the expected window → incident.
• ✓Hung LLM calls or tool calls: chain.invoke() blocks; overrun detection opens an incident after the grace window.
• ✓Stalled runs: with step reporting enabled, a run that stops making progress opens an incident naming the chain stage it wedged in, without waiting out the whole run budget.
• ✓Chain exceptions: the except block fires immediately, POSTing the exception type and message (up to 10,000 bytes) to the incident.
• ✓Works with LangSmith: the two systems are orthogonal; LangSmith traces what happens inside runs, LastPing monitors whether runs happen at all and whether they complete.
• ✓Agent self-registration: the agent can create its own monitor and wire pings via the MCP server, with no human in the loop.

Questions people ask

Front-loaded answers: the most important fact first.

• How do I monitor a LangChain agent running on a schedule?

  Wrap your chain.invoke() or AgentExecutor.run() call with a start ping before, a success ping after, and a fail POST in the exception handler. Create a heartbeat monitor in LastPing with your schedule so a run that never starts also opens an incident. Or connect the LastPing MCP server and let the agent instrument itself. Free for individuals, no monitor cap.

• What causes LangChain agents to hang?

  LangChain agents hang when they block waiting for an LLM response that never arrives (provider outage, network partition, rate limit without a request_timeout set), when a tool call doesn't return or blocks indefinitely (slow database, hung subprocess, infinite retry in a custom tool), or when the agent loops on a reasoning step without hitting a stop condition, such as an agent loop that exceeds max_iterations but catches the OutputParserException and retries forever. In all these cases, chain.invoke() or AgentExecutor.run() never returns and no exception propagates: the process simply hangs, and the start ping fires but the success or fail ping never arrives.

• Can I use LangChain callbacks for monitoring instead?

  LangChain callbacks (BaseCallbackHandler) fire on chain start, end, and error events but run inside the same process, so they can't detect hung calls (the thread is blocked) or missed scheduled executions (the process never started). The LastPing approach is complementary: the start and success pings bracket the entire run, and the external watchdog catches silence (hung runs, missed schedules) that's invisible from inside the chain's callback system.

• Does this work with LangGraph agents?

  Yes. LangGraph's CompiledGraph.ainvoke() or invoke() is a standard Python async coroutine or synchronous call, so wrap graph.invoke() or graph.ainvoke() the same way: start ping before invoke(), success ping after, fail POST in the except block. LangGraph's checkpointing doesn't change the external observability gap: the heartbeat watchdog catches hung, missed and never-started runs regardless of which orchestration layer (LangChain, LangGraph, or custom) is used.

• Is LangChain monitoring free in LastPing?

  Yes. LastPing is free for individuals with no monitor cap. The MCP server at mcp.lastping.dev is included. The same pattern applies to OpenAI Agents SDK and CrewAI agents: see OpenAI Agents SDK monitoring and CrewAI monitoring.