workflow-parallel-fanout-omits-sequential-phases v1.0.1A

Immutable. This exact content is served forever at /api/v1/blob/53eb8167babadd8b.

---
name: workflow-parallel-fanout-omits-sequential-phases
description: |
  A sequential, stateful multi-agent process (adversarial DEBATE rounds, iterative
  reflect-then-rebut, staged consensus where step N reads step N-1's peers) silently
  VANISHES when the task is run under "ultracode" or authored as a Workflow — the run
  collapses to a parallel find→verify→judge with no reviewer-to-reviewer cross-talk.
  Use when: (1) you ran "review / red-team / debate X in ultracode mode" and the
  workflow shows only ~3 stages (review → verify → judge), no
  debate/reflection/blind-final; (2) you invoked a multi-phase SKILL (e.g.
  roundtable:agent-review-panel) but
  the execution was a parallel fan-out with no agents reading each other; (3) a skill
  whose spec MANDATES sequential phases produced a result with those phases absent and
  it is NOT context-compression (that's the sister skill
  multi-agent-skill-silent-phase-compression). Counter-intuitive root cause: the
  Workflow/ultracode engine is a PARALLEL
  fan-out engine (parallel()/pipeline(), agents never see each other) with no primitive
  for sequential cross-talk — so "run it as a workflow" structurally omits debate, and
  invoking a skill under ultracode-bias ≠ running the skill's protocol.
author: Claude Code
version: 1.0.1
date: 2026-08-04
disable-model-invocation: true
---

# Running a sequential multi-agent process as a Workflow silently drops its sequential phases

## Problem

A multi-agent process that depends on **sequential, stateful cross-talk** — adversarial
debate rounds, reflect-then-rebut, blind-final-after-debate, any "step N reads step N−1's
peer outputs and responds" — **silently disappears** when the task is executed under
*ultracode* or hand-authored as a `Workflow`. The result looks like a clean 3-stage
**review → verify → judge** with no reviewer-to-reviewer argument, and reads as complete.
The judge ends up doing alone the reconciliation the debate was supposed to surface.

## Context / Trigger Conditions

- You said "review / red-team / stress-test X **in ultracode**" and the `/workflows`
  view shows ~3 stages at most: independent review → verify → judge. No debate /
  reflection / blind-final.
- You invoked a multi-phase **skill** (e.g. `roundtable:agent-review-panel`, which
  *mandates* Phase 5 Debate / 6 Summarize / 7 Blind-Final) but the actual execution was
  a parallel fan-out — N independent agents, then a judge — with zero agents reading each
  other's output.
- A skill spec lists mandatory sequential phases, yet the run has them absent — **and**
  it's not the context-compression failure (full skill ran, mid-phases squeezed out under
  token pressure → that's the sister skill, see below).

## Root cause

The `Workflow` tool / ultracode is a **parallel fan-out engine**: `parallel()` and
`pipeline()` run agents that **never see each other**. There is **no primitive for
sequential cross-talk** (agents reading peers' outputs and responding across rounds). The
tool's own canonical review recipe is literally **"find → adversarially verify → judge"** —
debate is not in its vocabulary. Three consequences, by frequency (from a week-long audit
of `roundtable:agent-review-panel` usage across dozens of runs, where **nearly every run
had no debate**):

1. **Ultracode biases toward authoring a Workflow instead of invoking the sequential
   skill.** The workflow it writes is find→verify→judge; debate was never in it.
2. **Debate-less sister skills get auto-selected** for small / autonomous-multi-PR work
   (e.g. a "streamlined parallel panel, no debate, no judge" skill) — debate-free *by
   design*.
3. **"Invoking a skill" ≠ "running its protocol"** in an ultracode/workflow-biased
   session: the skill name appears in the transcript, but execution collapses to a
   parallel shape. (Audit: the skill was invoked on the order of a dozen times, ran its
   full protocol only a couple of times, and actually debated just once.)

This is **structurally distinct** from silent phase *compression*: there, the full skill
runs and mid-pipeline phases get dropped under orchestrator context-budget pressure; HERE
the protocol **never ran** — a parallel, debate-less mode ran in its place.

## Solution

**To get the sequential phases back:**

1. **Invoke the skill WITHOUT ultracode/workflow framing.** `/roundtable:agent-review-panel`
   in a non-ultracode turn, or *"run the FULL panel with adversarial debate rounds — do
   not streamline, do not run it as a workflow."* The sequential phases live in the
   **skill's own Agent-tool orchestration**, not the Workflow engine.
2. **If you DO want cross-talk inside a Workflow, author it explicitly.** It's the default
   *absence* of cross-talk, not an impossibility: make round 2 a `pipeline()`/`parallel()`
   stage whose prompts are **fed round 1's peer outputs** so each agent rebuts what the
   others said, then judge. (Proven: one audited run used `phases [Review, Debate,
   Audit+Verify, Judge]` and debated correctly.)
3. **Make absence loud.** Stamp a `[NO-DEBATE]` / `[NO-CROSS-TALK]` banner on the output
   when the sequential phase produced no state — so a flattened run announces itself
   instead of looking complete.

**The discriminator — when does this even matter?** Fan-out with no cross-talk is *correct*
when the sub-tasks are **independent** (classify N transcripts, review N unrelated files,
search N angles) — there's nothing to debate. Sequential debate earns its cost **only when
agents would genuinely change each other's verdicts**: security-vs-performance tradeoffs,
"is this P0 actually real", merge/ship go-no-go. Drop cross-talk freely for independent
work; protect it for adversarial-tradeoff work. (Ironically, an *audit* of this very
problem correctly ran as a no-debate fan-out — independent transcripts.)

## Verification

- After forcing the skill path: the transcript shows agents reading each other's findings
  and revising (Phase 5/6/7 state files, e.g. `state/reviewer_*_phase_5_round1.md`), not
  just N independent reviews → judge.
- The output names a debate/rebuttal step with actual position changes, not a single
  judge integration.

## Notes

- **Sister skill — different root cause, same symptom:**
  [`multi-agent-skill-silent-phase-compression`](../multi-agent-skill-silent-phase-compression/SKILL.md)
  covers the case where the FULL skill *did* run but mid-pipeline phases were silently
  compressed under orchestrator context-budget pressure. If the skill genuinely ran its
  protocol and phases still vanished → that skill. If a parallel/streamlined/workflow mode
  ran *instead of* the protocol → this skill.
- The audit that surfaced this: a multi-agent Workflow over about a week of real usage;
  finding written up (anonymized) in the review-panel tool's own `docs/analysis/`. The
  repo-side fix (loud `[NO-DEBATE]` banner) is tracked as an issue there.
- General principle beyond review panels: **any** skill/process whose value is sequential
  state (iterative refinement, negotiation, multi-round consensus) is at risk of being
  flattened when "run as a workflow." Audit the executed shape, not the invoked name.