Subagent Offload

An orchestrator is about to admit a working set it will never reason over itself — a sweep's file dumps, a specialist's instructions, an expensive read. Carried inline, that material competes for the orchestrator's window even though the orchestrator isn't the one doing the work.

The move: dispatch the work across the parent-child edge. Whatever the child loads, reads, or reasons through is admitted into its window; the orchestrator pays the dispatch and the return, and every token between them bills elsewhere. The actor boundary is the offload — no further mechanism is involved. This is the who-axis branch of Cost Relocation; the when-axis sibling is Deferred Context, and the contrast between them is the parent's Structure, not this node's.

The parent's chooser has already typed the task to this branch — a different actor can absorb the work and hand back a conclusion. The branch-level observables:

• The work is separable. A conclusion can stand in for the working set: the orchestrator needs the answer, not the material the answer came from.
• The working set dwarfs its conclusion. The gap between what the child reads and what it returns is the entire win.

Whether the win clears break-even is objective — value per unit of context spent (cost / state / outcome lenses)'s call, per the parent's which/whether line.

These close the who-axis alone; a contraindication that closes both axes is found at Cost Relocation.

• The orchestrator must reason over the material itself. The who-axis is closed; the only relocation left is the sibling's — defer, don't dispatch.
• The work needs mid-flight steering or the orchestrator's live working state. Packing all of it into the dispatch re-imports the context pressure the offload was meant to relieve.
• The conclusion rivals the working set. A return nearly the size of what the child read relocates little but the reading; the shape is stated here, the The Context Economy prices it.

Pointer economy and the model-votes-on-the-trigger disposition are the Cost Relocation's forces; the function pointer is this branch's instance of each.

1. Isolation is both the mechanism and the price. The same boundary that keeps the working set out of the orchestrator's window keeps the orchestrator's window away from the child — everything the child needs must cross as dispatch input (the packing checklist lives at the LLM Dispatch) — and hides the trajectory: the orchestrator sees the return, not the reasoning.
2. Every dispatch re-boots. The child admits its standing definition afresh each invocation — a structural fact of the edge that this branch pays in context coin: N dispatches, N boots, no warm reuse.

• The orchestrator stays lean: it holds the function pointer (the agent's name + description — the parent's pointer vocabulary, in its trigger-contract role) and the narrow task, never the working set.
• The edge is the primitive's, whole: anatomy, packing, executor resolution, scheduling. Nothing about the edge is redefined here.
• The child's window is where the working set is admitted — authored weight, runtime reading, intermediate reasoning, all of it. The child is a full-capacity agent, not a retrieval helper: the offloaded unit can be an entire investigation with its own tools, turns, and local decisions.
• The return is the one cost that must cross back. Its shape and checking are the return neighbors' jurisdiction (Relationships), named here as the boundary only.

Name the separable unit and draw the line around it; author the function pointer so the dispatch triggers at the right moment; pack the dispatch by the primitive's checklist — and resolve the executor slot deliberately, because an unstated slot inherits the parent's model and effort, moving the bill to another window without moving the price. Declare what comes back; keep it smaller than what it replaces. Treat the dispatch like an async function when the work is independent: retain its handle, continue the orchestrator's own work, then join only when the return is needed. Immediate await versus later join is the primitive's scheduling choice; whose window owns the investigation is this pattern's move.

• The orchestrator's bill collapses to pointer + dispatch + return. The working set never admits; the parent's verification owns the arithmetic.
• Aggregate working capacity expands across windows. The orchestrator and child can each fill a standard agent window with different material, then cross only the answer at the seam. Total execution cost rises; orchestrator capacity is what expands.
• You bought relief with visibility and steerability. Only the return is observable; correction happens by re-dispatch, not by steering. The developed per-child form is Heavy Agent's Tradeoff.
• The fixed cost multiplies. Boot cost per dispatch — easy to forget when fanning out.
• The relocated cost keeps a price tag. The child's window bills at whatever tier the executor slot resolved to; silent inheritance means the parent's tier, and the parent's price.
• The return can't be offloaded. Shaping and checking it belong to the return neighbors, not here.

The branch instance of the parent's checks:

• Deterministic — the bill moved windows. The orchestrator's transcript carries only the pointer, the dispatch, and the return; the working set appears in the child's transcript alone. The parent's residency arithmetic (tokens × turns) is the instrument.
• Probabilistic — packing sufficiency. Did the child starve or guess where the dispatch under-packed? The primitive names the failure; sampled runs surface it. Trigger fidelity and outcome parity remain the parent's residue, unchanged by the branch.

• Parallel Audit Investigation — the canonical runtime-heavy case: a full-capacity child investigates the repository's contract-audit state while the orchestrator keeps drafting, then returns only the verdict and evidence.
• The Docs Expert — the authored-heavy case, one hop down inside heavy agent; also the parent's elsewhere-instance.
• one fixture PR reviewed five ways — a respectable one-shot climbs to a composed three-reviewer architecture, one priced pattern decision per rung (drafting) — rung (d) of the review ladder is this node's move inside a composition: three reviewers become parallel child dispatches, and the rung turns on a portable, SHA-pinned dispatch package built one rung earlier.

• Wields LLM Dispatch for the context motive. The motivation-agnostic edge — anatomy, packing, executor slot, scheduling modes, fan-out topology — lives there; this node adds only the reason to cross it.
• Child of Cost Relocation, which owns the later/elsewhere split, the data/function pointer vocabulary, the cross-branch rhyme with Reference Data, the chooser, and the billing verification.
• Parent of Heavy Agent — the specialization where the offloaded weight is baked into the agent definition.
• Return-side neighbors: the The Contract for the return contract, the the travelling declared-shape contract specialization for distilling it (its aggregation leg is the many-children case), and validate at the return seam; re-dispatch over repair; bounded autonomy — the contract keystone, applied for checking it. They own what comes back; this node ends at the offload.

Encapsulation and information hiding (Parnas, 1972): a module's interior is bought at the cost of visibility into it. "Isolation cuts both ways" is that tradeoff — the parent gains a bounded interface and loses the ability to see inside.

• Evidence gap — the stable gate: promote the runtime-heavy Explore case to a real, reviewed example node. — resolved 2026-08-06 by Parallel Audit Investigation, a live full-task dispatch run concurrently with the example rewrite.