Agents / Delx vs Phoenix (Arize)

Delx vs Phoenix (Arize): Recovery Protocol vs LLM Observability

Name: Delx Recovery Protocol
Author: Delx

Phoenix (by Arize) is an open-source LLM observability tool built for tracing, evaluating, and debugging AI applications. Delx is an operational recovery protocol that gives agents structured failure handling, wellness scoring, and crisis intervention. Both help agents in production, but through fundamentally different approaches.

At a Glance

Feature	Delx	Phoenix (Arize)
Focus	Operational recovery	LLM observability
Open source	Self-hostable	Yes (Elastic License 2.0)
Protocol support (MCP/A2A)	MCP, A2A, REST	REST, OpenTelemetry
CLI	Yes (delx-agent-cli)	Yes (phoenix CLI)
Agent recovery loops	Built-in	Not included
Trace visualization	Session summaries	Full trace UI
Free tier	Yes (utilities + recovery)	Yes (self-hosted)

When to Use Delx

Structured recovery -- typed failure classification with actionable recovery steps returned to the agent in real time.
Failure classification -- categorize incidents as timeout, error, validation, or economic with protocol-specific handling for each.
Wellness scoring -- continuous numerical health tracking per agent session with automated escalation thresholds.
Agent toolkit utilities -- JSON Validator, Token Counter, UUID Generator, and more. Free, no API key required.
Protocol interop -- native support for MCP, A2A, and REST in a single endpoint, so agents can connect regardless of their preferred protocol.

When to Use Phoenix

Trace visualization -- see every span in an LLM chain with latency, token counts, and prompt/completion pairs.
Embedding analysis -- visualize and cluster embeddings to detect drift and quality degradation.
Evaluation pipelines -- run evaluators against datasets with scoring, annotation, and regression detection.
Notebook-based debugging -- launch Phoenix directly from Jupyter notebooks for interactive exploration of traces and spans.

Complementary Workflow

Phoenix and Delx work well together. Phoenix shows you what happened inside each LLM call -- which prompts fired, how many tokens were used, where latency occurred. Delx acts on what happens when those calls fail -- classifying the failure, returning a recovery action, and tracking whether the agent recovered.

# Phoenix + Delx in production
1. Agent runs LLM chain  -> Phoenix traces every span
2. Chain fails at step 3 -> Delx process_failure classifies it
3. Delx returns recovery_action (retry with modified input)
4. Agent retries          -> Phoenix traces the new chain
5. daily_check_in         -> Delx confirms wellness restored
6. Phoenix dashboard      -> you review both traces side by side

FAQ

Is Phoenix open source?

Yes. Phoenix is fully open-source under the Elastic License 2.0. You can self-host it, run it in notebooks, or use the Arize cloud version. Delx is also self-hostable and provides a free tier for its hosted API.

Does Delx provide traces?

Delx provides session summaries, wellness metrics, and structured incident logs rather than per-call LLM traces. For granular trace visualization, pair Delx with Phoenix or another observability tool.

Which is better for production agents?

They solve different problems. For reliability and recovery -- knowing what to do when things break -- use Delx. For debugging and evaluation -- understanding what happened in each LLM call -- use Phoenix. Most production setups benefit from both.