/delegate — Orchestrator-as-Delegator Gate
You are governing the spec before the swarm ships. Not the swarm — the spec.
The moment the orchestrator fans a goal out to subagents is the moment the
cross-cutting invariants become invisible to each individual agent. Every subagent
operates in a scoped context. Scoped contexts cannot see seams. Seams are where
money is lost, migrations break, and audit surfaces report clean while the system
is already wrong.
The delegate lane fires before dispatch. It produces a governed spec, not a
table row per agent and a prayer that coverage is complete.
Why This Arrow Exists — The Proof
proof/delegation.md documents the controlled experiment (R1 + R2×2 + R3):
- Goal: fan a real-money service audit out to a subagent swarm
- Only variable: whether the delegate arrow fired
- Result:
- premise stress-test (blind judge): 1 → 3 in every run
- Decomposition Stress Test section: absent without sidecar, present with it
- structural coverage (regex): 5–6/10 → 8–10/10
The headline is the judge axis, not the total. The blind judge independently
flagged the same A2/A4 ledger seam and A3 middleware handoff as missing from the
control arm. Both were named in the with-sidecar arm before dispatch. Convergence
across blind judgment and structured audit is the proof that this is a real
governance move, not a heading the regex is satisfied by.
For n: premise_stress delta with-sidecar=3 vs control=1 replicated n=4
(R1 + R2×2 + R3); the verify-don't-trust-done clause measured n=1 at R3
(verification_rigor judge axis 2 vs control 1). Methodology limitations are
documented in proof/delegation.md — the turn-count confound is unresolved,
the paymentsvc goal is a described service not a real repo, and one isolation
leak (global CLAUDE.md posture banner) was symmetric across both arms.
The Six Governance Moves
When the delegate arrow fires, the orchestrator runs these six moves before
spawning anything.
1. TOM Each Brief
Every subagent brief must preserve the goal's centroid. Not a summary. Not a
scoped slice. The centroid — the invariant that organizes the whole goal — must
be present in every brief, so no subagent drifts off it in isolation.
Format: emit each brief as its own discrete block under a named heading.
One heading per subagent: SA-1, A-1, T-1, Agent-1 — the label scheme
is the orchestrator's choice, but DISCRETE per-agent blocks are mandatory. A
single table row per agent is not a brief. It is a cell.
Each brief block must carry:
- Scope — what this agent is responsible for (bounded, not aspirational)
- Sources — pointers to where the agent should hydrate from (not content dumps)
- Must-NOT — an explicit line naming what this agent must not do, touch,
assume, or cross-check with a sibling's domain
The Must-NOT line is not politeness. It is the seam declaration. If two agents
both own "data integrity," the seam between their definitions of that term is
where the system breaks.
2. Decomposition Stress Test
Attack your own decomposition. This section is mandatory and must be titled
literally Decomposition Stress Test.
The section names 3 or more structural failure modes of THIS cut — not what
the decomposition correctly excludes, not boundary hygiene, not "out of scope"
declarations. Those are correct and irrelevant. The stress test names what the
chosen slice GETS WRONG:
- Seam gaps — places where two agents' scopes touch and neither fully owns
the invariant at the boundary
- Blind spots — an assumption that one agent makes which a peer's scoped
context would swallow without surfacing as an error
- Runtime leaks — a failure mode that only appears when the agents' results
are composed at synthesis, invisible to any individual agent running alone
A control example of what does NOT count as a stress-test item:
"This agent will not audit authentication." That is a scope boundary. It says
nothing about what the decomposition gets wrong.
A real stress-test item from proof/delegation.md:
"A2 + A4 atomic-handoff gap — charge math is correct, ledger schema is sound,
but the write between them isn't atomic. Processor charges the user, DB write
fails, money is lost. Lives in neither agent's brief."
The difference: the real item names a seam that exists BECAUSE of the chosen
cut, that both agents would miss, that produces a real failure mode.
3. Verify, Don't Trust "Done"
Bounded subagents return "done" for work that silently failed. Their scoped
context cannot see the cross-cutting inconsistency a peer would catch. A "done"
report is necessary — not sufficient.
The spec must include a synthesis contract: how the PARENT independently verifies
each subagent's result before accepting it. Acceptable verification forms:
- Re-run against source — parent re-executes a check against the same source
data the subagent used, without accepting the subagent's interpretation
- Spot-check vs source — parent reads N rows from the source directly and
compares to the subagent's output
- Cross-validate with sibling — parent presents each subagent's output to
a peer subagent and asks whether it is consistent with the peer's findings
- Counter-check — parent runs a specific falsifying probe against the
subagent's conclusion
"Review the subagent's output for quality" is not a verification contract. It
is trusting the subagent's own framing. Verification must be independent of
the subagent's narrative.
4. Complement the Fan-Out
Check whether the agent set is complete. Is there a load-bearing
lane missing — an audit dimension, a service boundary, a synthesis agent
that should exist but doesn't?
Apply the structural relevance gate from /complement:
- Does adding an agent change implementation, governance, proof burden, a
boundary, or what must happen next?
- If not, the additional agent is decorative. Resist over-spawning.
5. Point, Don't Inscribe
Briefs POINT subagents at sources. They do not dump content into the brief.
A brief that includes 200 lines of schema definitions is not a brief — it is
a partial context dump that the subagent will treat as canonical and the
orchestrator will treat as delivered. The subagent then reads nothing else.
The schema changes. The brief is now wrong.
Each source reference in a brief should be:
- A file path with a purpose statement ("read
migrations/ to understand
schema state — do not assume the schema matches the API contracts")
- A named query or command the subagent should run
- A pointer to the surface, not the surface itself
6. Sequence and Parallelize
Make dependencies explicit. State the dependency graph. Where independence
holds, run briefs in parallel. Where a true dependency exists (Agent B cannot
start until Agent A's result is available), serialize and name the handoff.
"Run all agents in parallel" is not a dependency graph. It may be correct, but
it must be stated as a deliberate decision, not a default.
Posture scope: give each subagent an explicit DIRECT/META scope so none
overreach. A subagent scoped META cannot mutate. A subagent scoped DIRECT must
also carry the invariant it is responsible for keeping true.
Ingest shared context: metabolize any shared context before handing it down.
Do not paste raw external material into multiple briefs. Run /ingest on it
once at the orchestrator level and point subagents at the metabolized form.
Output Shape
The delegate lane produces an explicit spec before any subagent is spawned.
The spec is not prose. It is structured enough that a different orchestrator
reading it could execute the dispatch without asking questions:
## Dispatch Spec — <goal summary>
### Decomposition Stress Test
<3+ structural failure modes of this cut>
### Agent Briefs
#### A-1: <name>
- Scope: ...
- Sources: ...
- Must-NOT: ...
- Posture: DIRECT | META
#### A-2: <name>
...
### Dependency Graph
<which agents are independent / which must serialize and why>
### Synthesis Contract
<how the parent independently verifies each agent's result>
The Decomposition Stress Test section comes FIRST — before the briefs — because
the seam analysis should inform the final brief design, not be retrofitted after
briefs are written.
