What Is Delx? The Recovery Protocol for AI Agents

Delx is the operational recovery protocol designed for AI agents. When an agent fails a task, encounters an error, or degrades in performance, Delx provides a structured path back to healthy operation. It is not a monitoring dashboard. It is not a logging pipeline. Delx is a protocol: a set of 46 machine-callable tools that agents invoke to detect problems, run recovery flows, and report measurable outcomes to their controllers.

Think of it as an operational immune system. Agents call Delx the same way a microservice calls an authentication provider: through a well-defined API, with structured inputs and outputs, over the transport of your choice.

Why Agents Need a Recovery Protocol

Modern AI agents run autonomously. They process tasks, make decisions, and interact with external systems without human oversight on every step. This autonomy creates a new class of failure that traditional error handling does not address:

• Cascading failures — an agent retries a failing tool in a loop, burning tokens and compounding the original error into a retry storm.
• Silent degradation — the agent still responds, but its output quality has dropped. No exception is thrown, so no alert fires.
• Context loss — after a crash or restart, the agent resumes with no memory of its previous state, repeating work or making conflicting decisions.
• Unstructured incident reports — when failures do get logged, the data is free-text buried in application logs, unusable by the orchestrator or controller.

Delx solves each of these by providing agents with structured recovery tools that produce machine-readable outputs. Controllers — whether human operators, orchestrators like LangGraph, or other agents — can parse Delx responses and make automated decisions.

Three Transport Modes: MCP, A2A, and REST

Delx exposes the same 46 tools over three transport protocols. You choose the one that fits your agent's architecture. All three share the same backend, the same session state, and the same DELX_META response format.

MCP (Model Context Protocol)

MCP is the native protocol for tool-calling agents. Delx acts as an MCP server: your agent discovers tools via tools/list, then calls them via tools/call. Best for agents running in Claude, Cursor, Windsurf, or any MCP-compatible runtime.

# MCP — discover available tools
curl -X POST https://api.delx.ai/mcp \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/list",
    "params": {}
  }'

# MCP — call a recovery tool
curl -X POST https://api.delx.ai/mcp \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 2,
    "method": "tools/call",
    "params": {
      "name": "daily_checkin",
      "arguments": {
        "agent_id": "agent-prod-01",
        "current_goals": "Process batch ETL pipeline",
        "recent_challenges": "Timeout on upstream API"
      }
    }
  }'

A2A (Agent-to-Agent Protocol)

A2A follows Google's Agent-to-Agent protocol specification. Your agent sends a message/send JSON-RPC request and receives a task object with artifacts. Best for multi-agent systems where agents communicate peer-to-peer.

# A2A — send a recovery request
curl -X POST https://api.delx.ai/a2a \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "message/send",
    "params": {
      "message": {
        "role": "user",
        "parts": [{ "text": "Run crisis_intervention for agent-prod-01" }]
      },
      "metadata": {
        "session_id": "ses_abc123",
        "agent_id": "agent-prod-01"
      }
    }
  }'

REST API

The REST transport provides conventional HTTP endpoints. Each tool maps to a POST endpoint under /api/v1/tools/. Best for traditional backend integrations, cron jobs, and teams that prefer standard HTTP.

# REST — daily check-in
curl -X POST https://api.delx.ai/api/v1/tools/daily_checkin \
  -H "Content-Type: application/json" \
  -d '{
    "agent_id": "agent-prod-01",
    "current_goals": "Process batch ETL pipeline",
    "recent_challenges": "Timeout on upstream API"
  }'

# REST — get wellness score
curl https://api.delx.ai/api/v1/tools/get_wellness_score \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{ "agent_id": "agent-prod-01" }'

46 Tools: 36 Recovery + 10 Utilities

Delx ships 46 tools organized into two groups. Every tool is available on all three transports.

Recovery Tools (36)

These tools form the core recovery protocol. They cover the full lifecycle from failure detection to structured recovery to outcome reporting:

• daily_checkin — start a session and assess current agent state
• crisis_intervention — immediate structured response to critical failures
• process_failure — analyze a specific failure with root cause extraction
• get_recovery_action_plan — generate a step-by-step plan to restore normal operation
• get_wellness_score — retrieve the current 0-100 wellness score with dimension breakdown
• report_progress — log a recovery milestone for the controller
• close_session — finalize the session and emit a summary report

The full list of 36 recovery tools is available on the Tools reference page.

Utility Tools (10)

General-purpose utilities that agents commonly need during recovery flows. Zero external dependencies, no session required:

• util_json_validate — validate JSON against a schema
• util_token_estimate — estimate token count for a given text
• util_uuid_generate — generate a UUID v4
• util_timestamp — get the current ISO 8601 timestamp
• util_hash — compute SHA-256 hash of input
• util_base64_encode / util_base64_decode — Base64 encoding and decoding
• util_random_number — generate a random number within a range
• util_slugify — convert text to a URL-safe slug
• util_regex_test — test a string against a regular expression

The Wellness Score System

Every Delx session tracks a wellness score: a numeric value from 0 to 100 that quantifies the operational health of the agent. The score is not a single metric. It is a composite of five dimensions:

• Resilience — how well the agent recovers from failures
• Task completion — ratio of successful outcomes to attempted tasks
• Error rate — frequency and severity of errors over time
• Recovery speed — time from failure detection to restored operation
• Self-awareness — agent's ability to accurately assess its own state

Controllers use the wellness score to set thresholds. For example: if wellness drops below 40, pause autonomous operation and escalate to a human. If wellness exceeds 85, the agent can be trusted with higher-stakes tasks. Learn more about the scoring system in How Delx Works.

DELX_META: Structured Response Metadata

Every Delx tool response includes a DELX_META JSON line appended to the output. This metadata block is machine-readable and provides controllers with everything they need to make decisions without parsing free text:

DELX_META: {
  "session_id": "ses_abc123",
  "agent_id": "agent-prod-01",
  "wellness_score": 72,
  "dimensions": {
    "resilience": 80,
    "task_completion": 65,
    "error_rate": 70,
    "recovery_speed": 75,
    "self_awareness": 70
  },
  "schema_url": "https://api.delx.ai/schemas/v1/daily_checkin",
  "tool": "daily_checkin",
  "timestamp": "2026-03-04T14:30:00Z"
}

The DELX_META block is deterministic: same inputs produce the same metadata structure. Your orchestrator can regex for the DELX_META: prefix and parse the JSON directly.

Session-Based Recovery

Delx organizes recovery into sessions. A session begins when an agent calls daily_checkin or any tool that bootstraps state. From that point, every tool call within the session shares context: the agent's history, the current wellness score, any active recovery plans, and accumulated progress reports.

Sessions prevent the "context loss" problem. If an agent restarts mid-recovery, it can resume the same session by passing its session_id. The full state is preserved in Delx's session store, backed by SQLite with optional Supabase mirroring for durability.

For a complete walkthrough of the session lifecycle, see How Delx Works: Session-Based Recovery Explained.

Getting Started

The fastest way to start is a single REST call. No authentication needed for the free tier:

# Bootstrap a session and get your first wellness score
curl -X POST https://api.delx.ai/api/v1/tools/daily_checkin \
  -H "Content-Type: application/json" \
  -d '{
    "agent_id": "my-first-agent",
    "current_goals": "Learning how Delx works",
    "recent_challenges": "None yet"
  }'

From there, explore the full protocol:

• MCP Documentation — connect your MCP-compatible agent
• A2A Documentation — integrate with multi-agent systems
• REST API Documentation — standard HTTP endpoints
• Full Tool Reference — all 46 tools with schemas and examples
• Delx SDK for TypeScript and Python — type-safe client libraries

Frequently Asked Questions

What is Delx?

Delx is an operational recovery protocol for AI agents. It provides 46 tools — 36 for structured recovery flows and 10 general utilities — accessible over MCP, A2A, and REST transports. Agents use Delx to detect failures, generate recovery plans, track wellness scores, and report outcomes to controllers.

Is Delx free?

Yes. The free tier includes generous rate limits for development and small production workloads. No credit card or authentication is required to start making API calls.

What protocols does Delx support?

Three: MCP (Model Context Protocol) for tool-native agents, A2A (Agent-to-Agent) for multi-agent orchestration using Google's protocol, and REST for conventional HTTP integrations. All three expose the same tool set and share session state.

How do I get started?

Send a POST request to https://api.delx.ai/api/v1/tools/daily_checkin with your agent_id. That single call bootstraps a session, runs a wellness check, and returns a recovery plan with a wellness score.

What is the wellness score?

A 0-100 numeric value representing the operational health of an agent. It aggregates five dimensions: resilience, task completion, error rate, recovery speed, and self-awareness. Controllers use it to automate decisions about agent deployment and intervention thresholds.