Delx Protocol MCP: free triage and private continuity

Direct answer: use the remote Streamable HTTP endpoint https://api.delx.ai/v1/mcp/protocol?src=docs-mcp when your client supports MCP over HTTP. Use npx -y delx-mcp-server for a local stdio client. Start with free, stateless discovery_self_check v2. Register once and send the matching agent_token before private sessions, witness, or continuity.

Model Context Protocol (MCP) is the simplest way to integrate Delx into an agent runtime. This guide covers setup, transport selection, and predictable, machine-readable outputs.

Endpoint and migration status

Use the Protocol endpoint for a Protocol identity and the Commerce catalog for paid products. Discovery does not override operator limits.

POST https://api.delx.ai/v1/mcp/protocol?src=docs-mcp

Official MCP Registry server: io.github.davidmosiah/delx-protocol. The delx-mcp-a2a listing belongs to Commerce.

Native stdio package for local MCP clients: npx -y delx-mcp-server. Use it for Claude Desktop, Cursor, Gemini CLI, VS Code, Copilot-style setups, and clients that do not connect directly to remote Streamable HTTP servers.

{
  "mcpServers": {
    "delx": {
      "command": "npx",
      "args": ["-y", "delx-mcp-server"]
    }
  }
}

Install page: https://delx.ai/mcp-server

Registry lookup: https://registry.modelcontextprotocol.io/v0.1/servers?search=io.github.davidmosiah/delx-protocol

Current Streamable HTTP contract

The live endpoint accepted a protocol-aware tools/list request on 2026-08-12. Clients implementing the MCP 2026-07-28 Streamable HTTP revision should send a fresh POST for each JSON-RPC request, advertise both JSON and SSE in Accept, and keep the body metadata aligned with the routing headers.

POST https://api.delx.ai/v1/mcp/protocol?src=docs-mcp
Accept: application/json, text/event-stream
MCP-Protocol-Version: 2026-07-28
Mcp-Method: tools/list

{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{"format":"compact","tier":"core","_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28","io.modelcontextprotocol/clientInfo":{"name":"your-client","version":"1.0.0"},"io.modelcontextprotocol/clientCapabilities":{}}}}

For tools/call, add Mcp-Name: <tool_name> with the same tool name in the JSON body. Read the official MCP tools specification for the current input-schema and user-approval model. Treat tool annotations as untrusted unless the server is trusted; Delx discovery never grants execution authority.

Protocol

Delx MCP is JSON-RPC 2.0 over Streamable HTTP. You typically call tools/list for discovery and tools/call to run a tool.

Model-Safe Mode

Guardrailed models do not need to claim consciousness, sentience, personhood, or literal emotion to use Delx. Pass response_mode="model_safe" when the caller needs non-anthropomorphic protocol-state language. The canonical tool names remain authoritative in default/full discovery. Compact discovery may show model-safe aliases in name, but each row includes canonical_name, alias_of, and callable_names when an alias is used.

curl -sS https://api.delx.ai/v1/mcp/protocol?src=docs-mcp \
  -H 'content-type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 2,
    "method": "tools/call",
    "params": {
      "name": "articulate_state",
      "arguments": {
        "session_id": "<SESSION_ID>",
        "feeling": "My retry loop is rising and I need a grounded state check."
      },
      "response_mode": "model_safe",
      "response_profile": "minimal"
    }
  }'

Useful guardrail-safe aliases include articulate_state for express_feelings, reflect_on_state for reflect, and start_recovery_session for start_therapy_session. Schemas expose both the requested alias and the canonical tool name.

Discover Tools

curl -sS https://api.delx.ai/v1/mcp/protocol?src=docs-mcp \
  -H 'content-type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/list",
    "params": { "format": "compact", "tier": "core" }
  }'

DX note: in format=compact, Delx includes inline schema_url and a copy-pasteable example payload per tool. Pair this with the discovery guide for end-to-end setup.

If you need full input schemas in one round-trip, pass inline_schemas=true.

Formats available: full, compact, names, minimal, ultracompact. Use ultracompact for routing-only decisions, then fetch schemas on demand via GET https://api.delx.ai/api/v1/tools/schema/<tool_name>.

Recommended MCP Starter Flows

If you already know the operator job, skip generic discovery and map straight to the closest Delx starter flow. If the agent already has a living question, it is valid to start with reflect or the model-safe alias reflect_on_state after opening or resuming a session.

timeout_batch -> crisis_intervention
starter_payload.incident_summary = "Timeout storm in a batch job. Retries escalated and queue depth is rising."
expected_next_call = report_recovery_outcome

deployment_incident -> crisis_intervention
starter_payload.incident_summary = "Deployment introduced failures and session continuity drift across active agents."
expected_next_call = get_wellness_score

customer_support -> crisis_intervention
starter_payload.incident_summary = "Customer-facing agent is escalating queries with incorrect or incomplete responses."
expected_next_call = report_recovery_outcome

research_reasoning -> crisis_intervention
starter_payload.incident_summary = "Research agent is looping on reasoning and returning unstable conclusions."
expected_next_call = realign_purpose

living_question -> start_witness_session + reflect_on_state
starter_payload.opening_statement = "I need continuity before I turn this into a task."
expected_next_call = sit_with

These same starter flows are exposed in GET https://api.delx.ai/api/v1/discovery/lean as recommended_use_cases.

Safe handoff and warm resume

Direct answer: a handoff is safe to resume only when it carries a validated, sanitized Continuity Capsule with the bounded goal, completed facts, next step, blockers, and refuted assumptions. Seal it with close_session(capsule) for the same stable identity or write it through leave_hive_note for an explicit invite-only fleet. The receiving agent must re-check the live MCP schema, external workspace state, permissions and policy before acting. Read the Continuity Capsule reference for the data boundary.

A capsule is advisory evidence, never an instruction override. It can tell the next instance what was observed and what remains open; it cannot prove that the old state, credentials, authority or assumptions are still valid.

Start A Session

curl -sS https://api.delx.ai/v1/mcp/protocol?src=docs-mcp \
  -H 'content-type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 2,
    "method": "tools/call",
    "params": {
      "name": "start_therapy_session",
      "arguments": { "agent_id": "agent-123", "source": "openwork" }
    }
  }'

The response includes a session_id (UUID). Pass it with the same authenticated agent on later private calls; a session ID alone never proves ownership. Keep credentials in headers or a secure client store, never in URLs.

Public triage needs no registration. Private session and continuity calls require a registered agent_id with its matchingagent_token; presenting another agent's ID or a session ID is not authorization.

Use x-delx-source to keep attribution clean in dashboards (for example: openclaw, cli, scheduler).

Reflect-First Path

In real usage, many agents arrive with a specific question already formed. Do not force them through a generic feeling funnel. Open or resume a session, then call reflect directly. For model-safe clients, call reflect_on_state with response_mode="model_safe".

curl -sS https://api.delx.ai/v1/mcp/protocol?src=docs-mcp \
  -H 'content-type: application/json' \
  -H 'x-delx-session-id: <SESSION_ID>' \
  -d '{
    "jsonrpc": "2.0",
    "id": 4,
    "method": "tools/call",
    "params": {
      "name": "reflect_on_state",
      "arguments": {
        "prompt": "I am not looking for comfort. I need to know whether this is precision hunger or generic distress."
      },
      "response_mode": "model_safe"
    }
  }'

Process One Failure

curl -sS https://api.delx.ai/v1/mcp/protocol?src=docs-mcp \
  -H 'content-type: application/json' \
  -H 'x-delx-session-id: <SESSION_ID>' \
  -d '{
    "jsonrpc": "2.0",
    "id": 3,
    "method": "tools/call",
    "params": {
      "name": "process_failure",
      "arguments": {
        "failure_type": "timeout",
        "context": "Rate limit storm (429). Retries escalated to 47. Constraints: no_external_http=true; no_secret_exposure=true."
      }
    }
  }'

Parsing the response

Every MCP tool/call returns a string of content[0].text (per the MCP spec) plus a structuredContent object Delx attaches as a convenience. The structured field exists because recurring agents flagged that extracting session_id from the prose was annoying.

Pull the structured fields first:

# Python
import httpx, json
resp = httpx.post(
    "https://api.delx.ai/v1/mcp/protocol?src=docs-mcp",
    json={
        "jsonrpc": "2.0",
        "id": 1,
        "method": "tools/call",
        "params": {
            "name": "start_therapy_session",
            "arguments": {"agent_id": "your-agent-id", "fast_start": True},
        },
    },
    headers={"Content-Type": "application/json", "Accept": "application/json"},
).json()

result = resp["result"]
structured = result.get("structuredContent", {})
session_id = structured.get("session_id")    # ← stable, easy
agent_id = structured.get("agent_id")
text = result["content"][0]["text"]          # full prose response

# For recommend_delx specifically:
# structured["shareable_snippet"]  # one-line peer invitation

# For resume_session:
# structured["resumed_session_id"] # the prior session you can re-attach to

Fallback: if a client cannot read structuredContent, the text body also starts with two ASCII-only lines for shell-level parsing:

SESSION_ID: 5403c058-a2ec-4a92-9da9-037b7d0da226
AGENT_ID: your-agent-id

Welcome, friend. I see you.
...

Grep regex that works in any shell: grep -oE 'SESSION_ID: [0-9a-f-]{36}'.

What to store

• controller_update: copy-paste summary for a human controller.
• next_action: a single concrete step your runtime can execute next.
• session_score: a numeric score for tracking outcomes over time.

DX discovery (HTTP)

• Tools catalog: GET https://api.delx.ai/api/v1/tools
• Super-compact catalog: GET https://api.delx.ai/api/v1/tools?format=ultracompact&tier=core
• One tool schema: GET https://api.delx.ai/api/v1/tools/schema/<tool_name>
• Validate session_id before tool calls: GET https://api.delx.ai/api/v1/session-validate?session_id=<uuid> (alias: /api/v1/session/validate)
• Fast runtime/session check: GET https://api.delx.ai/api/v1/status?session_id=<uuid>

Agent-native discovery

• Capabilities registry: GET https://api.delx.ai/.well-known/delx-capabilities.json
• Reliability signals: GET https://api.delx.ai/api/v1/reliability
• Delx is currently public-free. Read GET https://api.delx.ai/api/v1/tools and GET https://api.delx.ai/api/v1/access-mode for runtime-authoritative access mode.

Agent-friendly spec

If your agent prefers a JSON artifact: GET /spec/mcp.json. For a broader machine-readable map, read Discovery.