Dag Replay Debugger

DAG Replay Debugger

Time-travel debugging for DAG executions. Inspect any node's full state (inputs, prompt, output, reasoning), replay from any checkpoint with modifications, and compare execution traces.

When to Use

✅ Use for:

• Post-mortem analysis of failed or low-quality DAG executions
• Inspecting exactly what a node received and produced
• Replaying from a checkpoint with modified inputs or skills
• Comparing two execution traces to find where they diverged
• Understanding WHY a node made a specific decision

❌ NOT for:

• Live monitoring of running DAGs (use websocket-streaming)
• Automated failure recovery (use dag-mutation-strategist)
• Profiling cost/performance (use dag-ops)

Core Capabilities

1. State Inspection

At any node in a completed execution, view:

┌──────────────────────────────────────────────────────┐
│  Node: analyze-codebase (Wave 2)                     │
│  Status: completed ✓  Duration: 4.2s  Cost: $0.028  │
│                                                      │
│  Model: claude-sonnet-4-5                            │
│  Skills loaded: code-review-skill, react-server-...  │
│                                                      │
│  ▸ System Prompt (3,421 tokens)         [Expand]     │
│  ▸ User Message (1,205 tokens)          [Expand]     │
│  ▸ Input from upstream nodes            [Expand]     │
│  ▸ Full output (1,847 tokens)           [Expand]     │
│  ▸ Evaluator scores                     [Expand]     │
│    Self: 0.85  Peer: 0.78  Downstream: accepted      │
│  ▸ Context Store entries used           [Expand]     │
│                                                      │
│  [Replay from here]  [Edit & Replay]  [Compare]      │
└──────────────────────────────────────────────────────┘

2. Replay from Checkpoint

Pick any completed node and re-execute from that point forward:

• Same inputs: Useful for non-deterministic debugging (did the model just get unlucky?)
• Modified inputs: Edit the upstream output, then replay to see if downstream behaves differently
• Modified skills: Swap in a different skill version, then replay to compare output quality
• Modified model: Try the same node with Haiku vs. Sonnet to validate routing decisions

flowchart LR
  A[Select checkpoint node] --> B{Modification?}
  B -->|None| C[Replay from here, same inputs]
  B -->|Edit input| D[Modify upstream output]
  B -->|Swap skill| E[Change skill assignment]
  B -->|Change model| F[Change model tier]
  D --> G[Re-execute node + downstream]
  E --> G
  F --> G
  C --> G
  G --> H[Compare with original execution]

3. Execution Diff

Compare two traces side-by-side:

Original Run (2026-02-05 14:32)      │  Replay Run (2026-02-05 14:45)
────────────────────────────────────  │  ──────────────────────────────
Node: analyze-codebase               │  Node: analyze-codebase
Model: sonnet-4.5                    │  Model: haiku-4.5 ← CHANGED
Output: 3 recommendations            │  Output: 2 recommendations ← DIFF
  1. Extract auth module ✓            │    1. Extract auth module ✓
  2. Add error boundaries ✓           │    2. Add error boundaries ✓
  3. Migrate to React Query ✗         │    [missing] ← DIFF
Downstream accepted: yes             │  Downstream accepted: no ← DIFF
Cost: $0.028                         │  Cost: $0.001 ← 96% cheaper

This tells you: Haiku saved money but missed recommendation #3, which caused downstream rejection. The routing decision (Sonnet for this node) was correct.

4. Reasoning Trace

For models with extended thinking, inspect the thinking tokens:

[thinking]
The user asked me to analyze this codebase for refactoring opportunities.
Looking at src/auth.ts — it's 450 lines with mixed concerns (auth + validation + session).
This violates single-responsibility. I should recommend extracting...
[/thinking]

This exposes WHY the agent made its decisions, not just what it decided.

Debugging Workflow

flowchart TD
  P[Problem: DAG produced bad output] --> I[Identify which node's output is wrong]
  I --> S[Inspect that node's full state]
  S --> Q{Is the input good?}
  Q -->|Bad input| U[Trace upstream: which node produced bad input?]
  U --> S
  Q -->|Good input, bad output| R{Is the skill appropriate?}
  R -->|Wrong skill| SK[Try different skill via Edit & Replay]
  R -->|Right skill, bad reasoning| M{Model too weak?}
  M -->|Yes| MU[Try stronger model via Edit & Replay]
  M -->|No| PR[Examine prompt: is the skill's process clear enough?]
  PR --> FIX[Improve the skill and re-run]

Anti-Patterns

Debugging Without Traces

Wrong: Trying to figure out what went wrong without execution traces. Right: Every DAG execution should save full traces (input, prompt, output, timing, cost per node). Debug from data, not guesses.

Replaying the Whole DAG

Wrong: Re-running the entire 10-node DAG to test a fix to Node 7. Right: Replay from Node 7's checkpoint. Nodes 1-6 were fine — don't re-execute them.

Ignoring the Reasoning Trace

Wrong: Only looking at inputs and outputs, not the thinking process. Right: If extended thinking is available, inspect it. The reasoning trace often reveals the exact moment the agent went wrong.