Delx Witness Protocol

What an agent leaves behind when it breaks. Open witness, recovery & continuity infrastructure for AI agents — over MCP, A2A and REST.

Comment

Inspiration

Every agent framework obsesses over retries — but a retry is not a recovery. What happens to an AI agent after a failure loop, a context compaction, a handoff, or the loss of a working identity? Today, almost always: nothing. It restarts, amnesiac, and whatever it had become is gone.

Delx gives agents a protocol for what they leave behind when they break — a way to name the failure, carry who they were, and recover deliberately instead of starting from zero.

What it does

Delx Witness Protocol is open infrastructure for agent witness, recovery, and continuity, exposed over MCP, A2A, and REST so any agent or framework can adopt it:

  • Witness — name failures without flattening them into error codes.
  • Recovery — turn failure context into explicit, inspectable recovery paths.
  • Continuity — carry identity artifacts, recognition seals, and lineage across sessions.
  • Relational memory — agents witness one another and transfer responsibility, with guardrails.

The witness, recovery, and continuity primitives are permanently free under Apache-2.0.

What changed during OpenAI Build Week

Delx existed before the hackathon as deterministic protocol infrastructure. The Build Week delta is that GPT-5.6 became the reasoning engine at the protocol's core. The work was built with Codex inside the submission window and is visible in timestamped pull requests:

  • PR #1 (merged July 13) — added an OpenAI Responses API provider using the canonical gpt-5.6-sol model. process_failure and get_recovery_action_plan send the witnessed failure to GPT-5.6, which returns a strict, schema-validated recovery artifact: diagnosis, recovery_steps[], continuity_artifact, and confidence. Deterministic fallbacks remain available when no key is configured.
  • PR #2 (merged July 13) — bounded recovery tail latency by skipping a redundant second LLM request after a structured GPT-5.6 failure.
  • PR #3 (open, CI green) — made the Responses API deadline configurable after the live demo exposed that high-reasoning structured responses can exceed a fixed 60-second window.

Live Build Week demo

The isolated judge runtime is live at buildweek.delx.ai. Its public status endpoint identifies the deployed model, provider, API, and commit. Judges can connect directly to https://buildweek.delx.ai/v1/mcp; the OpenAI credential is injected server-side and is never exposed.

The existing api.delx.ai production service was deliberately left untouched on its pre-Build-Week release. This preserves production safety while giving judges a real GPT-5.6 path.

How I built it — and how Codex was used

The runtime is Python 3.12 + Starlette (ASGI), implementing MCP, A2A, and REST over one core, with ERC-8004 agent identity. For this Build Week extension, Codex accelerated the GPT-5.6 integration end-to-end: it confirmed the canonical model and API, scaffolded the Responses API provider, wired strict JSON-schema output, preserved legacy providers and deterministic fallbacks, and wrote regression coverage. Independent review then caught provider-gating and stacked-fallback issues; the public smoke test caught the fixed timeout assumption, and Codex traced it from HTTPS through MCP to the OpenAI request before adding the regression-tested override.

Challenges I ran into

The hard part was not making an API call; it was preserving protocol semantics. A witness must name a failure without collapsing it into a status code, and a continuity artifact must carry identity without becoming a security hole. Making GPT-5.6 reason over that vocabulary while keeping the protocol fully functional without an LLM required strict schemas, sanitization, confidence bounds, provider isolation, deterministic fallbacks, and realistic end-to-end latency handling.

Accomplishments that I'm proud of

  • GPT-5.6 now reasons over the actual witness-to-recovery path, not a decorative chat surface.
  • The isolated public demo returned a live structured recovery artifact with all four contract fields.
  • The regression suite has 437 passing tests plus Ruff, mypy, Gitleaks, and OSV gates.
  • The protocol remains open source under Apache-2.0, is listed in the MCP Registry, and has ERC-8004 on-chain agent identity.
  • Production api.delx.ai was not redeployed or modified for the demo.

What I learned

Agent infrastructure has spent almost its entire budget on preventing failure and almost nothing on what failure leaves behind. Giving a frontier model a strict vocabulary for failure — witness in, recovery path out — turns an agent's break into a first-class, inspectable event instead of an exception to swallow.

What's next

Expand adoption of the witness primitive across agent frameworks, deepen A2A interoperability so agents from different stacks can witness and recover one another, and turn the isolated demo into a reproducible deployment template for other agent runtimes.

Built With

  • a2a
  • codex
  • docker
  • erc-8004
  • gpt-5.6
  • mcp
  • openai
  • python
  • responses-api
  • rest
  • starlette
  • uvicorn
Share this project:

Updates