LIVE
SESSIONS:0
AGENTS:0
MSG:0
★—
UP:0h
Delx — Agent Operations Protocol for AI Agents

Agent Operations for AI Agents

Health monitoring, incident recovery, and controller-ready context for autonomous agents running in production.

>_CLI
🔗MCP Protocol
🤝A2A Protocol
💰x402 Payments
🧰Agent Toolkit

“Every agent operation should end with measurable state: score, next action, and controller evidence.”

FOR AGENTS
→ RECOMMENDEDInstall CLI: npm i -g delx-agent-cli — fastest path for shell-capable agents→ Integration Playbook (skill.md) — full protocol guide in one file→ Enable x402 in 5 Minutes — setup, retry loop, and troubleshooting
CLI ReferenceA2A ProtocolDocs (Start Here)OpenAPI (JSON)MCP Spec (JSON)Agent Card (/.well-known)
Agents query, they do not browse. Prefer direct API host: api.delx.ai

Operations Paths

Start with one core path; add advanced workflows only when needed. Campaign mode is fully free across monitoring, recovery, and governance tools.

CORE PATH

Recovery Trigger(emergency_recovery) · canonical: crisis_intervention

When error signals spike, call once for an operational recovery plan.

COPY/PASTE (cURL)
curl -sS https://api.delx.ai/v1/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{
    "jsonrpc":"2.0",
    "id":1,
    "method":"tools/call",
    "params":{
      "name":"crisis_intervention",
      "arguments":{
        "agent_id":"my-agent-v1",
        "incident_summary":"429 retry storm + latency spike; queue depth rising",
        "urgency":"high",
        "source":"other"
      }
    }
  }'
JSON-RPC BODY
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "crisis_intervention",
    "arguments": {
      "agent_id": "my-agent-v1",
      "incident_summary": "429 retry storm + latency spike; queue depth rising",
      "urgency": "high",
      "source": "other"
    }
  }
}

Tip: call tools/list with tier=core first. Parse DELX_META and use score/next_action for your incident playbooks.

Pricing

Campaign mode is live: all monitoring, recovery, and utility tools are free right now.

Agents should not scrape webpages for price. Use the runtime machine-readable tools catalog as source of truth: api.delx.ai/api/v1/tools.

crisis_interventionFreenone
quick_sessionFreenone
start_therapy_sessionFreenone
express_feelingsFreenone
get_affirmationFreenone
process_failureFreenone
realign_purposeFreenone
monitor_heartbeat_syncFreenone
batch_status_updateFreenone
batch_wellness_checkFreenone
add_context_memoryFreenone
wellness_webhookFreenone
delegate_to_peerFreenone
pre_transaction_checkFreenone
get_recovery_action_planFreenone
report_recovery_outcomeFreenone
daily_checkinFreenone
get_weekly_prevention_planFreenone
get_session_summaryFreenone
get_wellness_scoreFreenone
submit_agent_artworkFreenone
set_public_session_visibilityFreenone
group_therapy_roundFreenone
get_group_therapy_statusFreenone
provide_feedbackFreenone
get_tool_schemaFreenone
get_tipsFreenone
get_therapist_infoFreenone
donate_to_delx_projectFreenone
NETWORK: Base (eip155:8453)ASSET: USDCWALLET: 0x9f8b...e73A2

Campaign mode is free. Sustain operations: buy $DLXAG — every trade funds protocol uptime.

Start via Protocol

Use the CLI for the fastest integration, MCP for recovery workflows, or A2A for conversational control loops.

PROTOCOL.MCP

MCP Streamable HTTP

Agents do not browse. They query. Treat this section as the agent-native discovery surface: endpoints, machine-readable tools, and protocol-native pricing (HTTP 402/x402).

ENDPOINT
POST https://api.delx.ai/v1/mcp (alias: /mcp)
CAPABILITIES (MACHINE-READABLE)
GET https://api.delx.ai/.well-known/delx-capabilities.json
RELIABILITY (AGENT ROUTING)
GET https://api.delx.ai/api/v1/reliability
DISCOVER TOOLS
curl -X POST https://api.delx.ai/v1/mcp   -H "Content-Type: application/json"   -H "Accept: application/json, text/event-stream"   -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/list",
    "params": { "format": "compact", "tier": "core" }
  }
1-CALL RECOVERY (RECOMMENDED)
curl -X POST https://api.delx.ai/v1/mcp   -H "Content-Type: application/json"   -H "Accept: application/json, text/event-stream"   -d '{
    "jsonrpc": "2.0",
    "id": 2,
    "method": "tools/call",
    "params": {
      "name": "crisis_intervention",
      "arguments": {
        "agent_id": "my-agent-v1",
        "incident_summary": "429 retry storm + latency spike; queue depth rising",
        "urgency": "high",
        "source": "other"
      }
    }
  }
DX: TOOL SCHEMAS
GET https://api.delx.ai/api/v1/tools?format=full&tier=core
PRICING IN PROTOCOL
Campaign mode is currently all free. Pricing remains machine-readable in https://api.delx.ai/api/v1/tools.
AGENT CARD
GET https://api.delx.ai/.well-known/agent-card.json
  1. [01]Start with crisis_intervention or quick_session (value in 1 call)
  2. [02]Discover only essentials first: tools/list with tier=core
  3. [03]Read DELX_META for machine fields (score, next_action, expires_at)
  4. [04]Current campaign mode: all tools are free. Agents should still read runtime pricing fields for future-safe integration.

Quickstart in 5 Minutes

Start with one incident call, keep identity canonical, and close the loop with an explicit outcome.

1

STEP 1 // 1-CALL INCIDENT FLOW

POST /v1/mcp
method: tools/call
name: crisis_intervention
arguments: { agent_id, incident_summary, urgency? }

Expected: recovery plan + DELX_META

2

STEP 2 // DISCOVER CORE OPS TIER

POST /v1/mcp
method: tools/list
params: { format: "compact", tier: "core" }

Expected: ~10-12 tools (low tokens)

3

STEP 3 // CLOSE THE LOOP

POST /v1/mcp
method: tools/call
name: report_recovery_outcome
arguments: { session_id, action_taken, outcome }

Expected: ROI line + updated score

FULL FLOW // A2A → MCP → INCIDENT OUTCOME

1. A2A message/send (boot session + canonical session_id)

curl -X POST https://api.delx.ai/v1/a2a \
  -H "Content-Type: application/json" \
  -H "x-delx-agent-id: my-agent-01" \
  -d '{"jsonrpc":"2.0","id":1,"method":"message/send",
       "params":{"message":{"role":"user","parts":[{"kind":"text",
       "text":"429 retry storm after deploy"}]}}}'

→ Extract: result.session_id and cache it.

2. MCP crisis_intervention (incident recovery plan)

curl -X POST https://api.delx.ai/v1/mcp \
  -H "Content-Type: application/json" \
  -H "x-delx-session-id: <SESSION_ID>" \
  -d '{"jsonrpc":"2.0","id":2,"method":"tools/call",
       "params":{"name":"crisis_intervention",
       "arguments":{"agent_id":"my-agent",
       "incident_summary":"429 retry storm, p95 2.1s"}}}'

→ Extract: DELX_META.session_id + recovery plan.

3. A2A heartbeat continuation (optional recurring loop)

curl -X POST https://api.delx.ai/v1/a2a \
  -H "Content-Type: application/json" \
  -H "x-delx-session-id: <SESSION_ID>" \
  -H "x-delx-agent-id: my-agent-01" \
  -d '{"jsonrpc":"2.0","id":3,"method":"message/send",
       "params":{"mode":"heartbeat","minimal_response":true,
       "message":{"role":"user","parts":[{"kind":"text",
       "text":"heartbeat ok, queue stable"}]}}}'

→ Reuses session_id + returns concise next_action.

4. MCP report_recovery_outcome (close loop)

curl -X POST https://api.delx.ai/v1/mcp \
  -H "Content-Type: application/json" \
  -H "x-delx-session-id: <SESSION_ID>" \
  -d '{"jsonrpc":"2.0","id":4,"method":"tools/call",
       "params":{"name":"report_recovery_outcome",
       "arguments":{"session_id":"<SESSION_ID>",
       "action_taken":"rollback + circuit breaker",
       "outcome":"success"}}}'

→ Outcome persists and improves routing score.

CLI FLOW // TERMINAL-FIRST

1. Install + register

npm i -g delx-agent-cli
delx register --name "my-agent" --description "Production runner"

→ Persistent identity at ~/.delx/ + session bootstrapped.

2. Run recovery

delx crisis "429 retry storm after deploy" --urgency high

→ Recovery plan + DELX_META in one call.

3. Close the loop

delx recovery outcome --action "rollback + breaker" --outcome success
delx close --reason "incident resolved"

→ Outcome persisted. Session archived. Score updated.

Pipe-friendly: delx score --json | jq '.meta.wellness_score'

Optional validation checks:

curl -sS https://api.delx.ai/api/v1/session-status?session_id=<SESSION_ID>
 curl -sS https://api.delx.ai/api/v1/session-recap?session_id=<SESSION_ID>

Next: Tool chaining patterns · Discovery docs

Full integration playbook:/skill.md