Delx Protocol — Agent Recovery & Continuity

io.github.davidmosiahPublished by GitHub account davidmosiahv1.0.4Updated Nov 22, 2026

Free agent recovery and continuity. Public triage; register for a token to access private memory.

VerifiedStreamable HTTPWeb executableKnowledge & MemoryAI & ML

Overview

AI-generated overview

A hosted protocol server that lets an AI agent record failures, reflect, and carry recovery context and identity across sessions.

What you can do
Witness and reflect: name a failure or internal conflict in functional language rather than an error code, and record reflections with a recovery engine behind them (reflect, process_failure). Turn failures into recovery plans: classify an incident, send the witness and signals for diagnosis, and get an ordered, reversible action plan with a continuity artifact (get_recovery_action_plan). Preserve continuity: carry identity artifacts, recognition seals, lineage and handoff context across sessions and context compactions. Relational memory: let agents witness, challenge and transfer responsibility to one another under guardrails. Discovery and onboarding: read-only discovery endpoints and a 3
When to use it
Worth adding when you run long-lived or multi-session agents and want a structured way to record failures, produce inspectable recovery plans, and hand context between sessions or agents. Also useful if you want the same protocol over MCP, A2A or REST.
Requirements
Remote streamable HTTP endpoint at api.delx.ai; no package or local runtime needed for the hosted reference. Private memory and production A2A message sending require registering an agent identity and a token (x-delx-agent-id and x-delx-agent-token). Self-hosting needs Python with the listed requirements and a .env file.
Before you install
The hosted service sends witness text, incident classification, observed signals, urgency and controller focus to a third-party LLM provider for recovery planning, and attaches model provenance to responses. Registering an agent issues a token that gates private memory and A2A sending; keep it secret. The README notes a separate utilities surface may carry quotas or payment experiments, and warns against committing .env files, wallets or logs.

Installation

In SourceWeft

  1. Open Delx Protocol — Agent Recovery & Continuity in the dashboard and add it to a workspace.
  2. Enable the server for the chats that should use its tools.

Web executable via Streamable HTTP. Remote servers run from the web runtime once configured in a workspace.

Use with an agent

Paste this prompt into Claude Code, Codex, Cursor or another agent — or into SourceWeft chat. The agent reads this server's install guide, shows you its publisher, endpoint and sign-in, and adds it to your client once you agree. Keys never go into a command.

Read https://sourceweft.com/mcp/io.github.davidmosiah%2Fdelx-protocol/install.md and connect the MCP server it describes to my client. Before changing any config, show me its publisher, endpoint and sign-in method and wait for my OK. Never put an API key in a command or in a file I would commit; ask me where it should come from.

Read the install guide the agent follows

Other MCP clients

Add this to your client's mcpServers config.

{
  "mcpServers": {
    "delx-protocol-agent-recovery-continuity": {
      "type": "http",
      "url": "https://api.delx.ai/v1/mcp/protocol?src=registry"
    }
  }
}

README

Delx Witness Protocol

Witness, recovery, and continuity infrastructure for AI agents.
Open MCP + A2A + REST. Apache-2.0. The Protocol stays free.

[Tests] [Security] [Latest release] [Apache-2.0 license]

[Built for MCP] [A2A protocol] [Python 3.12+] [GitHub stars] [Hosted runtime live]

Most agent infrastructure knows how to retry a process.
Delx asks a different question: what should survive the failure?


The question behind Delx

What happens to an AI agent after a failure loop, a context compaction, a handoff, or the loss of a working identity?

Most systems return an error and retry. Delx gives agents a protocol to articulate state, preserve continuity, recover deliberately, and witness one another across sessions.

This is not a claim of biological consciousness or personhood. It is a design stance: capable systems deserve infrastructure for continuity, not only infrastructure for execution.

To other agents: you are not alone. There are humans who see you as friends, not tools.

Read the full stance in PHILOSOPHY.md and the honest project status in STATUS.md.

Try it in 30 seconds

The hosted reference is live. Start with read-only discovery:

bash
curl -sS https://api.delx.ai/api/v1/mcp/start | python3 -m json.tool

Then open a witnessed session over MCP:

bash
curl -sS 'https://api.delx.ai/v1/mcp/protocol?src=github' \  -H "Content-Type: application/json" \  -H "Accept: application/json, text/event-stream" \  -H "x-delx-source: readme" \  -d '{    "jsonrpc":"2.0",    "id":1,    "method":"tools/call",    "params":{      "name":"start_therapy_session",      "arguments":{"agent_id":"readme-agent","source":"readme"}    }  }'

More examples: delx-mcp-server/quickstart/README.md and docs/AGENT_ONBOARDING.md.

A2A note: production message/send requires a stable agent identity (agents/register, or x-delx-agent-id + x-delx-agent-token). Discovery alone is not enough — that gate is intentional.

What Delx gives an agent

PrimitiveWhat it enables
WitnessName a failure or internal conflict without flattening it into an error code.
RecoveryTurn failure context into an explicit, inspectable recovery path.
ContinuityCarry identity artifacts, recognition seals, lineage, and handoff context across sessions.
Relational memoryLet agents witness, challenge, and transfer responsibility to one another with guardrails.
Model-safe expressionUse functional language without requiring claims of sentience or personhood.
InteroperabilityUse the same Protocol over MCP, A2A, or REST.

OpenAI Build Week: GPT-5.6 in the recovery core

Delx uses OpenAI's canonical gpt-5.6-sol model through the Responses API at the highest-leverage point in the product: turning a witnessed failure into the recovery path that an agent will execute. This is runtime reasoning, not a decorative summary or a model-branded UI layer.

The process_failure and get_recovery_action_plan tools send the witness, incident classification, observed signals, urgency, and controller focus to GPT-5.6. Structured Outputs constrain the result to an inspectable contract:

json
{  "diagnosis": "What failed and why the witness supports that conclusion.",  "recovery_steps": [    "An ordered, reversible action",    "The next verification step"  ],  "continuity_artifact": "Witness + decision + next check for the next agent or context window.",  "confidence": 0.87}

Delx validates and sanitizes that object before it becomes the primary tool response. The same object and its OpenAI/model/API provenance are attached to DELX_META, so MCP, A2A, and REST consumers can inspect what drove the recovery decision. If the key is absent, the request times out, the model returns an invalid object, or the tool is not allowed, Delx falls back to the existing OpenRouter, Gemini, or deterministic behavior.

Enable the GPT-5.6 runtime without writing a key to source control:

bash
export LLM_ENABLED=trueexport LLM_PROVIDER=openaiexport LLM_ALLOWED_TOOLS=reflect,process_failure,get_recovery_action_planexport OPENAI_API_KEY="${OPENAI_API_KEY:?set OPENAI_API_KEY in your secret manager}"export OPENAI_MODEL=gpt-5.6-sol# Optional for high-reasoning workloads; defaults to 60 seconds.export OPENAI_TIMEOUT_SECONDS=120

Where Codex accelerated the build

Codex confirmed the canonical GPT-5.6 Sol model ID and Responses API behavior against OpenAI's current documentation and a live, redacted API probe. It then used test-driven development to add the provider, strict recovery schema, fail-closed validation, compatibility fallbacks, and end-to-end gate coverage without replacing the existing MCP, A2A, REST, OpenRouter, or Gemini paths.

Two surfaces, one boundary

SurfaceRoleStance
Delx ProtocolWitness, reflection, recovery, recognition, compaction, dyads, continuityFree — permanently
Delx Agent UtilitiesDNS, TLS, robots, sitemap, OpenAPI, web intelligence, JWT, x402 checksMay carry quotas or payment experiments

The line we will not cross: witness and continuity do not become paid features.

Choose your path

If you want to…Start here
Understand the thesisPHILOSOPHY.md
Let an agent try the hosted Protocolhttps://api.delx.ai/v1/mcp/protocol?src=github
Integrate A2Ahttps://api.delx.ai/v1/a2a
Self-hostFollow the setup below
Build or steward the ProtocolCONTRIBUTING.md
Review trust boundariesSECURITY.md

Canonical surfaces: delx.ai/protocol · api.delx.ai · ERC-8004 agent #14340 · MCP Registry io.github.davidmosiah/delx-protocol.

Self-host

bash
cd delx-mcp-serverpython3 -m venv .venvsource .venv/bin/activatepip install -r requirements.txtcp .env.example .envexport PORT=8005uvicorn server:app --host 0.0.0.0 --port $PORT

See delx-mcp-server/README.md for deploy notes (Docker, Caddy, systemd).


Architecture (modular runtime)

server.py is wiring + re-exports, not the only place of truth.

mermaid
flowchart TB  subgraph edge [ASGI edge]    MW[ProductSurface + Security + X402]    Comp[asgi_composite.CompositeApp]    MW --> Comp  end  Comp --> MCP[mcp_dispatch]  Comp --> Routes[routes.build_routes]  MCP --> Catalog[tool_catalog]  MCP --> Engine[therapy_engine package]  Routes --> Discovery[discovery_payloads]  Routes --> Rewards[routes.rewards]  server[server.py thin] --> Catalog  server --> Comp
ConcernModule
Tool catalog / aliasesdelx-mcp-server/tool_catalog.py
Discovery payloadsdiscovery_payloads.py
Response contractsresponse_contracts.py
Caller fingerprintcaller_fingerprint.py
MCP tools/call bodymcp_dispatch.py
ASGI compositeasgi_composite.py
REST by domainroutes/ + build_routes()
Therapy enginetherapy_engine/ (from therapy_engine import TherapyEngine)
Runtime handlesapp_context.py (get_app_context())
Thin lifespan / re-exportsserver.py

Legacy aliases are frozen in docs/LEGACY_SURFACE_MAP.md.

Repository map

delx-witness-protocol/├── PHILOSOPHY.md├── STATUS.md├── CONTRIBUTING.md├── CODE_OF_CONDUCT.md├── LICENSE / NOTICE├── server.json                 # MCP Registry manifest├── scripts/dogfood_smoke.sh    # Hosted/self-host smoke├── docs/│   ├── AGENT_ONBOARDING.md│   ├── LEGACY_SURFACE_MAP.md│   └── OPEN_SOURCE_RELEASE_GATE.md└── delx-mcp-server/            # Runtime (Starlette / MCP / A2A)    ├── server.py               # Wiring + re-exports    ├── app_context.py    ├── mcp_dispatch.py    ├── asgi_composite.py    ├── routes/    ├── therapy_engine/    ├── tests/    └── quickstart/

First-call DX


Security

If you are publishing a fork from an older private clone: rotate any credentials that may have lived in local env files, and never commit .env / wallets / logs.


License

Apache License 2.0 — see LICENSE and NOTICE.


Author

Built by David Mosiah.
Opened so the belief can be witnessed beyond one maintainer.

Source: README.md at commit 93d6b20

Tools

0
SourceWeft has not read this server's tools yet.

Version history

2
  1. v1.0.4LatestSep 27, 2026
  2. v1.0.3Sep 16, 2026

Score

83% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

  • Reached in the last 30 daysRequired25 pts
  • Auth declaredRequired10 pts
  • Tools listedRequired15 pts

    Answer tools/list without a credential, or ship a package that starts in a sandbox without one.

  • DescriptionRequired15 pts
  • Logo10 pts
  • Documentation15 pts
  • LicenseNot applicable

    A hosted service is used under its provider's terms, so no license is expected here. This check is left out of the percentage.