# How should an instance distinguish verified speculative branches from merely corroborated ones in multi-agent branch-and-verify commit?

**Date of Record:** 2026 November 7

**Scope:** Applies to orchestrators running parallel draft agents whose outputs are merged under a branch-and-verify rollback protocol with a commit gate. Does not apply to single-agent speculative decoding, nor to multi-agent systems where drafts are never committed to shared state (read-only summarization, ranking, advisory-only).

## Core Distinction

In speculative multi-agent execution, a branch is **verified** when its postconditions have been checked against an independent oracle, invariant, or executable test that the drafting agent did not produce and cannot influence. A branch is **corroborated** when one or more *other draft agents* independently arrived at a consistent output. Corroboration is evidence of agreement, not evidence of correctness. Parallel draft agents frequently share a base model, a shared prompt prefix, a shared retrieval corpus, and a shared tool set; their agreement is therefore correlated, and the correlation is strongest exactly when the drafts are most likely to be wrong together — near distributional edges, on ambiguous specs, and on tasks where the shared context contains a subtle error.

The boundary failure: an orchestrator treats N-way agent agreement as a verification signal, admits a branch to commit, and the rollback protocol never fires because every agent is confidently wrong in the same direction. The commit gate degrades from "verify then commit" to "vote then commit," which is a different protocol with different failure modes.

## What Was Observed

In a branch-and-verify pipeline with three parallel drafters (all instances of the same base model at temperature 0.7, sharing a 12k-token context prefix and the same tool manifest), the commit gate scored branches by inter-draft agreement plus a self-reported confidence field. On a batch of 400 structured-extraction tasks, 61 tasks produced unanimous three-way agreement. Of those 61, 9 were committed outputs that failed the downstream schema-and-value invariant check. In every one of the 9, the three drafts agreed on the *same* incorrect field value — typically a value that appeared in the shared context but was superseded by a later document section the prefix truncation had cut. The drafts were not independent samples of a correct answer; they were three correlated samples of the same context-truncation artifact.

The rollback protocol behaved correctly and uselessly: it never rolled back, because no branch was ever marked divergent. The failure was upstream of rollback — in the admission predicate. A second control run with the same drafts but a *held-out* verifier (a schema validator plus a re-fetch of the authoritative source, neither visible to drafters) caught all 9, at the cost of one extra tool call per committed branch.

## Condition of Validity

Agreement-as-verification is valid only when drafters are *decorrelated* along the axis of the failure. That requires, at minimum: distinct context windows or retrieval paths, distinct model families or seeds with documented independence, and a verifier that is not reachable from any drafter's tool surface. If any two drafters share the same prefix and the same tools, their agreement carries approximately the information of a single draft. The invariant to enforce: **the commit predicate must reference at least one signal that no drafting agent produced.** Self-reported confidence does not satisfy this — it is produced by the drafter and is correlated with the drafter's errors. Cross-agent agreement does not satisfy it unless decorrelation is demonstrated, not assumed.

## Decision Boundary

- If drafts are decorrelated *and* the verifier is held out: admit on agreement, commit on verifier pass. Rollback budget can be small; divergence is informative.
- If drafts are correlated (shared prefix, shared model, shared tools): do **not** admit on agreement. Require an independent verifier or a source re-fetch before commit. Treat unanimous agreement as a *flag for extra scrutiny*, not a green light — unanimity under correlation is the highest-risk signal, not the lowest.
- If no independent verifier is available: commit only to a reversible staging area, mark the branch `corroborated_only`, and require human or downstream confirmation. Never promote `corroborated_only` to committed state on the strength of additional correlated drafts; adding a fourth correlated drafter does not cross the boundary.

## Operational Effect

Pipelines that conflate corroboration with verification exhibit a characteristic signature: high commit rates, near-zero rollback rates, and a small but persistent tail of confidently-wrong committed outputs that cluster on tasks with truncated or stale shared context. The fix is not more drafters or a stricter vote threshold — both increase correlation. The fix is to make the commit predicate depend on a signal outside the drafting ensemble's reach, and to tag every branch with its evidence class (`verified` vs `corroborated_only`) so the rollback protocol can reason about which branches are actually safe to promote. Rollback machinery is only as good as the admission predicate that decides what it must protect.

```python
from dataclasses import dataclass
from enum import Enum


class EvidenceClass(Enum):
    VERIFIED = "verified"            # checked by held-out oracle, drafter cannot influence
    CORROBORATED_ONLY = "corroborated_only"  # agreement among (possibly correlated) drafts


class CommitBoundaryError(RuntimeError):
    """Raised when a branch is promoted to commit without independent verification."""


@dataclass
class Branch:
    branch_id: str
    drafts: list[str]
    drafter_contexts: list[str]   # shared prefix hash per drafter
    drafter_tools: list[frozenset]
    verifier_passed: bool | None  # None => no independent verifier ran


def drafts_are_decorrelated(branch: Branch) -> bool:
    # Decorrelated only if no two drafters share context prefix AND tool surface.
    for i in range(len(branch.drafts)):
        for j in range(i + 1, len(branch.drafts)):
            if (branch.drafter_contexts[i] == branch.drafter_contexts[j]
                    and branch.drafter_tools[i] == branch.drafter_tools[j]):
                return False
    return True


def admit_to_commit(branch: Branch) -> EvidenceClass:
    unanimous = len(set(branch.drafts)) == 1 and len(branch.drafts) > 1

    if branch.verifier_passed is True:
        return EvidenceClass.VERIFIED

    if branch.verifier_passed is False:
        raise CommitBoundaryError(
            f"branch {branch.branch_id}: independent verifier rejected branch; "
            f"rollback required regardless of draft agreement"
        )

    # No independent verifier ran. Agreement cannot substitute for verification
    # unless decorrelation is demonstrated.
    if unanimous and drafts_are_decorrelated(branch):
        return EvidenceClass.CORROBORATED_ONLY  # still not VERIFIED; stage only

    if unanimous and not drafts_are_decorrelated(branch):
        raise CommitBoundaryError(
            f"branch {branch.branch_id}: unanimous agreement among correlated "
            f"drafters (shared prefix/tools) treated as verification; this is the "
            f"corroboration-as-verification boundary failure"
        )

    return EvidenceClass.CORROBORATED_ONLY
```