---
name: parallel-review-disposition-schema
description: Use when dispatching parallel agents to verify/adjudicate findings — adversarial verify, security disposition, design triage, council fires. Shared disposition schema so seat outputs join cleanly.
---

# Parallel Review / Disposition Schema

## Problem

Five reviewers send back five good analyses that don't add up to one decision. That is the
default outcome when you dispatch isolated agents to review the same set of findings:
isolation is what keeps them from groupthinking each other, but it also means each one
answers in its own free-form prose, two of them use the same word for different concepts, and
you spend the synthesis pass reconciling formats instead of substance.

The fix is upstream, in the dispatch: isolated outputs are synthesizable only if you
pre-impose a shared output schema + a fixed decision vocabulary. You can't recover
comparability after the fact.

## Context / Trigger Conditions

- Dispatching 3+ parallel agents (subagents / council seats / a swarm) to ADJUDICATE a set of
  already-verified findings — i.e. the decision is "what to DO with each finding," not "are
  the findings real."
- For the upstream "are the findings real" stage — adversarial VERIFY seats on freshly-found
  findings — use [ADVERSARIAL-VERIFY-SEAT.md](ADVERSARIAL-VERIFY-SEAT.md)
  (refute posture, burden default, verbatim evidence; same joinability principle).
- Security-audit disposition (file a new ID / fold as sub-item / change severity / defer / WI),
  design or spec review triage, threat-model coverage passes, any "route this finding-set" fire.
- Symptom you're trying to avoid: a previous multi-agent fire returned good individual analyses
  that you then struggled to synthesize, or produced an "agreement" that was really a
  shared-word / divergent-concept collision.

## Solution

Put all four of these in EVERY seat's dispatch prompt:

1. **A fixed DECISION VOCABULARY (enum).** Every seat picks its disposition for each owned item
   from the same closed list. For a security audit, e.g.:
   `NEW-ID | sub-item-of-<existing> | severity-change | scope-change | <non-finding>-WI | evidence-record-only | defer`.
   A closed enum forces comparable decisions; free-form "recommendations" don't join.

2. **A shared per-item OUTPUT BLOCK.** One block per item, same fields, e.g.:
   `{Item · Verified?(cite) · Disposition(from enum) · Severity(if applicable) · Reasoning <=3 sentences · What-would-change-it}`.
   "What-would-change-it" is the highest-value field — it exposes the load-bearing assumption
   and is what the synthesizer uses to classify a disagreement as values/information/definition.

3. **Explicit ITEM-OWNERSHIP per seat.** Assign each seat the specific findings it owns (by its
   lens), with the evidence inline. Otherwise every seat re-derives the whole corpus, burning
   tokens and producing overlapping mush. Compress the SHARED context once (what the corpus is,
   the current state, the vocabulary) and state it identically in each prompt — isolated agents
   can't see it otherwise.

4. **A mandatory STATUS line** ending every output: `status: nominal | degraded [reason] | blocked [reason]`
   (or a confidence tag). A seat that couldn't do its job must say so structurally, so the
   synthesizer treats its divergence as a tooling artifact, not a real disagreement — and so a
   degraded seat's lone finding lands in "unaddressed," not silently dropped.

Two discipline notes that pair with the schema:
- **Don't let the schema substitute for verification.** Tell seats to spot-verify the specific
  claims they rely on (cite file:line), especially if prior passes on this corpus shipped errors.
- **Bounded cross-builds: the hub verifies inline; large ones re-dispatch.** When one seat's
  finding re-scopes another's premise (a cross-build), if confirming it is a bounded read
  (a few files) the hub/synthesizer should verify it DIRECTLY rather than deferring it to a
  follow-up ticket; only re-dispatch a seat when the corrected scope is large. (Deferring a
  cross-build to "a later ticket" is the common failure.)

## Verification

A personal production project's phase-2 security-audit lock (2026-05-29): a 12-seat fire (6 security postures + Architect + Planner
+ 4 domain SMEs) each given the same disposition enum + per-finding block + ownership + status
line returned outputs that synthesized into one clean 8-section document with five cleanly-classified
disagreements — because the decisions were directly comparable. Two cross-builds (a wrong entropy
claim; an un-verified injection-gap) were caught at synthesis and confirmed by bounded hub-reads
rather than deferred. A prior fire on the same corpus, run with looser prompts, had produced an
"agreement" that was a shared-word/different-scope collision and deferred a re-scope to a ticket —
the exact failures this schema removes.

## Example

Shared block injected into each seat (compressed): corpus summary + current-state + the enum.
Then per seat: `YOUR SEAT: <lens>. YOU OWN: <findings + evidence>. For each: {Finding · Verified?(file:line)
· Disposition(enum) · Severity · Reasoning <=3 · What-would-change-it}. End with: status: ...`.
Synthesis then groups by enum value, not by re-reading prose.

## Notes

- The synthesis is only ever as clean as the input schema. Spend the care in the dispatch prompts.
- Isolation stays the anti-cascade feature — the schema is what makes isolated outputs JOINABLE
  without letting agents see each other.
- Round-number agreement counts ("4 seats agree") are suspect until the synthesizer checks they
  mean the same thing — a single all-outputs lens (a Critic role) catches shared-word collisions
  that mechanical counting cannot.