Skip to main content
A self-healing agent is one whose production failures reach a coding agent automatically, with the evidence attached, so remediation starts from the detection instead of from a person relaying context. Latitude closes that loop end to end: traffic is observed, recurring patterns become tracked signals, escalations dispatch your coding agent, and the fix lands as a pull request that a person reviews, backed by a regression test in your CI.
The self-healing loop: your agent, telemetry, signals, escalation, coding agent, pull request.

​
How the loop closes

1

Detect failures in production

Connect telemetry so every interaction arrives as a trace and multi-turn conversations group into sessions. Find failures with Search when you can describe them, or let Behaviours surface the topics and trends you would not think to look for. Annotations and flaggers record what you find, and Latitude groups those into named, tracked signals.
2

Score live traffic continuously

Give a signal an evaluation, a script that can combine code rules, semantic similarity, and LLM judgment, and live traffic is scored as it arrives. The evaluation’s trigger controls how much: generated evaluations start at a 10 percent sample, so raise the sampling and adjust the filters if the signal needs full coverage. Evaluations generated from your annotations carry an alignment record, so how often the script agrees with a human reviewer is a measured number.
3

Escalate what is growing

A signal escalates when its recent occurrences clear its own weekly rhythm, and monitors extend the same mechanism to saved searches and raw traffic metrics such as cost, latency, or cache hit rate. Either one opens an incident.
4

Dispatch your coding agent

With agent dispatch configured, an escalating signal or an open incident wakes your coding agent with a prompt, a deep link, and sample failing traces. Latitude is the trigger and the context provider, not the agent runtime: the dispatched agent runs in your environment, with your credentials, against your repository. Direct integrations exist for Claude Code, Cursor, and Linear, with webhooks for everything else.
5

Verify the fix and lock it in CI

The dispatched agent investigates through the MCP server, reading the signal, slicing occurrences, and reading the failing conversations, then opens a pull request. Turn the failing traces behind the signal into a dataset and add a regression test that replays it in CI, so the fix has to pass before it merges and every later prompt change is checked against the same failure.

​
Where humans stay

Two points of the loop are human by design. Annotations are the ground truth that evaluations are aligned against, and a person reviews every pull request before it merges. Everything between those points, finding examples, reconstructing context, and carrying trace ids between tools, is what the loop automates.

​
Set it up

  1. Start tracing one production agent.
  2. Annotate a handful of real failures, or let flaggers do it.
  3. Generate an evaluation for the signal that matters most.
  4. Add a monitor for any metric you cannot afford to miss.
  5. Configure agent dispatch under Settings → Integrations.
Your coding agent can drive the whole workspace through the MCP server:
For other coding agents, see the MCP server docs.