---
title: "Subagent Offload · pattern · Agentic Atlas"
description: "Subagent Offload: handing work to a subagent so its material never fills the orchestrator's context."
canonical: "https://agentic-atlas.dev/nodes/subagent-offload"
last-updated: "2026-09-23"
---

1. [Agentic Atlas](https://agentic-atlas.dev/)
2. [Patterns in the Agentic Atlas](https://agentic-atlas.dev/atlas)
3. [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation)
4. Subagent Offload

Parent of [Heavy Agent](https://agentic-atlas.dev/nodes/heavy-agent).

Seen working in [Parallel Audit Investigation](https://agentic-atlas.dev/nodes/parallel-audit-investigation).

1. pattern
   # Subagent Offload
   **When should you delegate to a subagent?**
   Delegate separable work when the orchestrator needs only the conclusion, not the material behind it.
   Hook
   handing work to a subagent so its material never fills the orchestrator's context
   Laws & fences
   - The boundary that shields the orchestrator also hides the child's reasoning and hides the orchestrator's context from the child.
   - Every dispatch starts the child from scratch, so its startup cost repeats and grows when launching many children.
   - The child's work bills at the child's model price, which defaults to the parent's when left unset.
   - Keep the child's returned answer smaller than the material it replaces, or little context is saved.
   - Do not offload work the orchestrator must reason over itself or steer while it runs.
   - Offloading expands the orchestrator's usable capacity, but total execution cost rises.
   When to reach
   - Reach for this when a side task's working set dwarfs the conclusion the orchestrator needs from it.
   - Reach for this when a file sweep or expensive read would crowd an orchestrator that never reasons over it.
   Provenance
   [subagent-offload/use-when](https://agentic-atlas.dev/nodes/subagent-offload#use-when) · v1.0.11
   Addresses
   atlas_cards subagent-offload
2. [Heavy Agent](https://agentic-atlas.dev/nodes/heavy-agent)
3. [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation)
4. [LLM Dispatch](https://agentic-atlas.dev/nodes/llm-dispatch)
5. [Deferred Context](https://agentic-atlas.dev/nodes/deferred-context)
6. [Context Efficiency](https://agentic-atlas.dev/nodes/context-efficiency)
7. [Parallel Audit Investigation](https://agentic-atlas.dev/nodes/parallel-audit-investigation)
8. [Reference Data](https://agentic-atlas.dev/nodes/reference-data)
9. [The Docs Expert](https://agentic-atlas.dev/nodes/docs-expert-agent)
10. [The Context Economy](https://agentic-atlas.dev/nodes/context-economy)
11. [The Contract](https://agentic-atlas.dev/nodes/contract-documentation)
12. [Context Flow](https://agentic-atlas.dev/nodes/context-flow)
13. [One Guide, Three Bills](https://agentic-atlas.dev/nodes/one-guide-three-bills)
14. [The Session Bill](https://agentic-atlas.dev/nodes/session-bill)
15. field notes
    - “one fixture PR reviewed five ways — a respectable one-shot climbs to a composed three-reviewer architecture, one priced pattern decision per rung”
    - “the travelling declared-shape contract specialization”
    - “validate at the return seam; re-dispatch over repair; bounded autonomy — the contract keystone, applied”

Reference DataThe Docs Expert +6 more unfold the map fold the map

The card, in place · its connections drawn edges from atlas_links subagent-offload

On this plate

[intent](https://agentic-atlas.dev/nodes/subagent-offload#intent) [use-when](https://agentic-atlas.dev/nodes/subagent-offload#use-when) [avoid-when](https://agentic-atlas.dev/nodes/subagent-offload#avoid-when) [forces](https://agentic-atlas.dev/nodes/subagent-offload#forces) [structure](https://agentic-atlas.dev/nodes/subagent-offload#structure) [application](https://agentic-atlas.dev/nodes/subagent-offload#application) [consequences-and-tradeoffs](https://agentic-atlas.dev/nodes/subagent-offload#consequences-and-tradeoffs) [verification](https://agentic-atlas.dev/nodes/subagent-offload#verification) [examples](https://agentic-atlas.dev/nodes/subagent-offload#examples) [relationships](https://agentic-atlas.dev/nodes/subagent-offload#relationships) [lineage](https://agentic-atlas.dev/nodes/subagent-offload#lineage) [open-questions-todo](https://agentic-atlas.dev/nodes/subagent-offload#open-questions-todo) [relationships-ledger](https://agentic-atlas.dev/nodes/subagent-offload#relationships-ledger)

Every section is addressable on its own. Read only the ground you need.

## Intent

[Permalink to Intent section](https://agentic-atlas.dev/nodes/subagent-offload#intent)

An [orchestrator](https://agentic-atlas.dev/glossary/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](https://agentic-atlas.dev/glossary/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](https://agentic-atlas.dev/glossary/return), and every token between them bills elsewhere. The [actor](https://agentic-atlas.dev/glossary/actor) boundary is the offload — no further mechanism is involved. This is the who-axis branch of [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation); the when-axis sibling is [Deferred Context](https://agentic-atlas.dev/nodes/deferred-context), and the contrast between them is the parent's *Structure*, not this node's.

## Use when

[Permalink to Use when section](https://agentic-atlas.dev/nodes/subagent-offload#use-when)

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 [Context Efficiency](https://agentic-atlas.dev/nodes/context-efficiency)'s call, per the parent's which/whether line.

## Avoid when

[Permalink to Avoid when section](https://agentic-atlas.dev/nodes/subagent-offload#avoid-when)

These close the who-axis alone; a contraindication that closes both axes is found at [Cost Relocation](https://agentic-atlas.dev/nodes/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](https://agentic-atlas.dev/nodes/context-economy) prices it.

## Forces

[Permalink to Forces section](https://agentic-atlas.dev/nodes/subagent-offload#forces)

[Pointer](https://agentic-atlas.dev/glossary/pointer) economy and the model-votes-on-the-trigger disposition are the [Cost Relocation](https://agentic-atlas.dev/nodes/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](https://agentic-atlas.dev/nodes/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.

## Structure

[Permalink to Structure section](https://agentic-atlas.dev/nodes/subagent-offload#structure)

- The **orchestrator** stays lean: it holds the function pointer (the agent's name + description — the parent's pointer vocabulary, in its [trigger-contract](https://agentic-atlas.dev/glossary/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.

## Application

[Permalink to Application section](https://agentic-atlas.dev/nodes/subagent-offload#application)

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.

## Consequences and tradeoffs

[Permalink to Consequences and tradeoffs section](https://agentic-atlas.dev/nodes/subagent-offload#consequences-and-tradeoffs)

- **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](https://agentic-atlas.dev/glossary/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](https://agentic-atlas.dev/nodes/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.

## Verification

[Permalink to Verification section](https://agentic-atlas.dev/nodes/subagent-offload#verification)

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.

## Examples

[Permalink to Examples section](https://agentic-atlas.dev/nodes/subagent-offload#examples)

- **[Parallel Audit Investigation](https://agentic-atlas.dev/nodes/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](https://agentic-atlas.dev/nodes/docs-expert-agent)** — 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.

## Relationships

[Permalink to Relationships section](https://agentic-atlas.dev/nodes/subagent-offload#relationships)

- **Wields [LLM Dispatch](https://agentic-atlas.dev/nodes/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](https://agentic-atlas.dev/nodes/cost-relocation)**, which owns the later/elsewhere split, the data/function pointer vocabulary, the cross-branch rhyme with [Reference Data](https://agentic-atlas.dev/nodes/reference-data), the chooser, and the billing verification.
- **Parent of [Heavy Agent](https://agentic-atlas.dev/nodes/heavy-agent)** — the [specialization](https://agentic-atlas.dev/glossary/specialization) where the offloaded weight is baked into the [agent definition](https://agentic-atlas.dev/glossary/agent-definition).
- **Return-side neighbors:** the [The Contract](https://agentic-atlas.dev/nodes/contract-documentation) 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.

## Lineage

[Permalink to Lineage section](https://agentic-atlas.dev/nodes/subagent-offload#lineage)

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.

## Open questions / TODO

[Permalink to Open questions / TODO section](https://agentic-atlas.dev/nodes/subagent-offload#open-questions-todo)

- **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](https://agentic-atlas.dev/nodes/parallel-audit-investigation), a live full-task dispatch run concurrently with the example rewrite.

The relationships ledger

Evidence-bearing references

## Relationships

Every connection keeps the section where it was found. The map above orients; this ledger carries the evidence.

### Outbound references 19

1. in-slice · occurrence 1
   [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation)
   context that costs by its size on every turn but is only needed sometimes
   Evidence: [Intent](https://agentic-atlas.dev/nodes/subagent-offload#intent) · occurrence 1
2. in-slice · occurrence 2
   [Deferred Context](https://agentic-atlas.dev/nodes/deferred-context)
   keeping a short pointer loaded and fetching bulky context only when a session needs it
   Evidence: [Intent](https://agentic-atlas.dev/nodes/subagent-offload#intent) · occurrence 2
3. in-slice · occurrence 1
   [Context Efficiency](https://agentic-atlas.dev/nodes/context-efficiency)
   how much task value you get for each unit of context spent
   Evidence: [Use when](https://agentic-atlas.dev/nodes/subagent-offload#use-when) · occurrence 1
4. in-slice · occurrence 1
   [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation)
   context that costs by its size on every turn but is only needed sometimes
   Evidence: [Avoid when](https://agentic-atlas.dev/nodes/subagent-offload#avoid-when) · occurrence 1
5. in-slice · occurrence 2
   [The Context Economy](https://agentic-atlas.dev/nodes/context-economy)
   what each piece of context costs, in quality, dollars, and latency, and who pays
   Evidence: [Avoid when](https://agentic-atlas.dev/nodes/subagent-offload#avoid-when) · occurrence 2
6. in-slice · occurrence 1
   [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation)
   context that costs by its size on every turn but is only needed sometimes
   Evidence: [Forces](https://agentic-atlas.dev/nodes/subagent-offload#forces) · occurrence 1
7. in-slice · occurrence 2
   [LLM Dispatch](https://agentic-atlas.dev/nodes/llm-dispatch)
   one LLM execution starting another, whether the parent waits, joins later, or never joins
   Evidence: [Forces](https://agentic-atlas.dev/nodes/subagent-offload#forces) · occurrence 2
8. in-slice · occurrence 1
   [Heavy Agent](https://agentic-atlas.dev/nodes/heavy-agent)
   subagents that carry heavy baked-in instructions the orchestrator never loads
   Evidence: [Consequences and tradeoffs](https://agentic-atlas.dev/nodes/subagent-offload#consequences-and-tradeoffs) · occurrence 1
9. in-slice · occurrence 1
   [Parallel Audit Investigation](https://agentic-atlas.dev/nodes/parallel-audit-investigation)
   a full investigation's working set stays in another agent's window; only its verdict returns
   Evidence: [Examples](https://agentic-atlas.dev/nodes/subagent-offload#examples) · occurrence 1
10. in-slice · occurrence 2
    [The Docs Expert](https://agentic-atlas.dev/nodes/docs-expert-agent)
    an agent with large docs built in, so the orchestrator asks instead of loading them
    Evidence: [Examples](https://agentic-atlas.dev/nodes/subagent-offload#examples) · occurrence 2
11. undisclosed · occurrence 3
    Undisclosed relationship
    one fixture PR reviewed five ways — a respectable one-shot climbs to a composed three-reviewer architecture, one priced pattern decision per rung
    Evidence: [Examples](https://agentic-atlas.dev/nodes/subagent-offload#examples) · occurrence 3
12. in-slice · occurrence 1
    [LLM Dispatch](https://agentic-atlas.dev/nodes/llm-dispatch)
    one LLM execution starting another, whether the parent waits, joins later, or never joins
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/subagent-offload#relationships) · occurrence 1
13. in-slice · occurrence 2
    [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation)
    context that costs by its size on every turn but is only needed sometimes
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/subagent-offload#relationships) · occurrence 2
14. in-slice · occurrence 3
    [Reference Data](https://agentic-atlas.dev/nodes/reference-data)
    a reference corpus too big to load into the context window at any price
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/subagent-offload#relationships) · occurrence 3
15. in-slice · occurrence 4
    [Heavy Agent](https://agentic-atlas.dev/nodes/heavy-agent)
    subagents that carry heavy baked-in instructions the orchestrator never loads
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/subagent-offload#relationships) · occurrence 4
16. in-slice · occurrence 5
    [The Contract](https://agentic-atlas.dev/nodes/contract-documentation)
    the agreement on an artifact's shape and use whenever one component hands it to another
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/subagent-offload#relationships) · occurrence 5
17. undisclosed · occurrence 6
    Undisclosed relationship
    the travelling declared-shape contract specialization
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/subagent-offload#relationships) · occurrence 6
18. undisclosed · occurrence 7
    Undisclosed relationship
    validate at the return seam; re-dispatch over repair; bounded autonomy — the contract keystone, applied
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/subagent-offload#relationships) · occurrence 7
19. in-slice · occurrence 1
    [Parallel Audit Investigation](https://agentic-atlas.dev/nodes/parallel-audit-investigation)
    a full investigation's working set stays in another agent's window; only its verdict returns
    Evidence: [Open questions / TODO](https://agentic-atlas.dev/nodes/subagent-offload#open-questions-todo) · occurrence 1

### Inbound references 22

1. in-slice · occurrence 3
   [Context Efficiency](https://agentic-atlas.dev/nodes/context-efficiency#implications-the-consequence-map)
   handing work to a subagent so its material never fills the orchestrator's context
   Evidence: [Implications](https://agentic-atlas.dev/nodes/context-efficiency#implications-the-consequence-map) · occurrence 3
2. in-slice · occurrence 5
   [Context Efficiency](https://agentic-atlas.dev/nodes/context-efficiency#relationships)
   handing work to a subagent so its material never fills the orchestrator's context
   Evidence: [Relationships](https://agentic-atlas.dev/nodes/context-efficiency#relationships) · occurrence 5
3. in-slice · occurrence 4
   [Context Flow](https://agentic-atlas.dev/nodes/context-flow#relationships)
   handing work to a subagent so its material never fills the orchestrator's context
   Evidence: [Relationships](https://agentic-atlas.dev/nodes/context-flow#relationships) · occurrence 4
4. in-slice · occurrence 2
   [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation#avoid-when-both-axes-closed)
   handing work to a subagent so its material never fills the orchestrator's context
   Evidence: [Avoid when](https://agentic-atlas.dev/nodes/cost-relocation#avoid-when-both-axes-closed) · occurrence 2
5. in-slice · occurrence 4
   [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation#structure-two-branches-one-per-axis)
   handing work to a subagent so its material never fills the orchestrator's context
   Evidence: [Structure](https://agentic-atlas.dev/nodes/cost-relocation#structure-two-branches-one-per-axis) · occurrence 4
6. in-slice · occurrence 5
   [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation#relationships)
   handing work to a subagent so its material never fills the orchestrator's context
   Evidence: [Relationships](https://agentic-atlas.dev/nodes/cost-relocation#relationships) · occurrence 5
7. in-slice · occurrence 2
   [Deferred Context](https://agentic-atlas.dev/nodes/deferred-context#intent-the-problem-and-the-move)
   handing work to a subagent so its material never fills the orchestrator's context
   Evidence: [Intent](https://agentic-atlas.dev/nodes/deferred-context#intent-the-problem-and-the-move) · occurrence 2
8. in-slice · occurrence 2
   [Deferred Context](https://agentic-atlas.dev/nodes/deferred-context#relationships)
   handing work to a subagent so its material never fills the orchestrator's context
   Evidence: [Relationships](https://agentic-atlas.dev/nodes/deferred-context#relationships) · occurrence 2
9. in-slice · occurrence 3
   [The Docs Expert](https://agentic-atlas.dev/nodes/docs-expert-agent#choice-why-it-s-a-heavy-agent-not-just-subagent-offload)
   handing work to a subagent so its material never fills the orchestrator's context
   Evidence: [Choice](https://agentic-atlas.dev/nodes/docs-expert-agent#choice-why-it-s-a-heavy-agent-not-just-subagent-offload) · occurrence 3
10. in-slice · occurrence 1
    [Heavy Agent](https://agentic-atlas.dev/nodes/heavy-agent#use-when-the-weight-is-authored)
    handing work to a subagent so its material never fills the orchestrator's context
    Evidence: [Use when](https://agentic-atlas.dev/nodes/heavy-agent#use-when-the-weight-is-authored) · occurrence 1
11. in-slice · occurrence 1
    [Heavy Agent](https://agentic-atlas.dev/nodes/heavy-agent#avoid-when-where-the-pattern-ends)
    handing work to a subagent so its material never fills the orchestrator's context
    Evidence: [Avoid when](https://agentic-atlas.dev/nodes/heavy-agent#avoid-when-where-the-pattern-ends) · occurrence 1
12. in-slice · occurrence 1
    [Heavy Agent](https://agentic-atlas.dev/nodes/heavy-agent#forces)
    handing work to a subagent so its material never fills the orchestrator's context
    Evidence: [Forces](https://agentic-atlas.dev/nodes/heavy-agent#forces) · occurrence 1
13. in-slice · occurrence 1
    [Heavy Agent](https://agentic-atlas.dev/nodes/heavy-agent#application)
    handing work to a subagent so its material never fills the orchestrator's context
    Evidence: [Application](https://agentic-atlas.dev/nodes/heavy-agent#application) · occurrence 1
14. in-slice · occurrence 1
    [Heavy Agent](https://agentic-atlas.dev/nodes/heavy-agent#verification)
    handing work to a subagent so its material never fills the orchestrator's context
    Evidence: [Verification](https://agentic-atlas.dev/nodes/heavy-agent#verification) · occurrence 1
15. in-slice · occurrence 1
    [Heavy Agent](https://agentic-atlas.dev/nodes/heavy-agent#relationships)
    handing work to a subagent so its material never fills the orchestrator's context
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/heavy-agent#relationships) · occurrence 1
16. in-slice · occurrence 1
    [LLM Dispatch](https://agentic-atlas.dev/nodes/llm-dispatch#model-and-claims)
    handing work to a subagent so its material never fills the orchestrator's context
    Evidence: [Model and claims](https://agentic-atlas.dev/nodes/llm-dispatch#model-and-claims) · occurrence 1
17. in-slice · occurrence 2
    [LLM Dispatch](https://agentic-atlas.dev/nodes/llm-dispatch#relationships)
    handing work to a subagent so its material never fills the orchestrator's context
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/llm-dispatch#relationships) · occurrence 2
18. in-slice · occurrence 3
    [One Guide, Three Bills](https://agentic-atlas.dev/nodes/one-guide-three-bills#choice)
    handing work to a subagent so its material never fills the orchestrator's context
    Evidence: [Choice](https://agentic-atlas.dev/nodes/one-guide-three-bills#choice) · occurrence 3
19. in-slice · occurrence 1
    [Parallel Audit Investigation](https://agentic-atlas.dev/nodes/parallel-audit-investigation#choice)
    handing work to a subagent so its material never fills the orchestrator's context
    Evidence: [Choice](https://agentic-atlas.dev/nodes/parallel-audit-investigation#choice) · occurrence 1
20. in-slice · occurrence 3
    [Reference Data](https://agentic-atlas.dev/nodes/reference-data#examples)
    handing work to a subagent so its material never fills the orchestrator's context
    Evidence: [Examples](https://agentic-atlas.dev/nodes/reference-data#examples) · occurrence 3
21. in-slice · occurrence 4
    [Reference Data](https://agentic-atlas.dev/nodes/reference-data#relationships)
    handing work to a subagent so its material never fills the orchestrator's context
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/reference-data#relationships) · occurrence 4
22. in-slice · occurrence 4
    [The Session Bill](https://agentic-atlas.dev/nodes/session-bill#implementation-the-six-shifts)
    handing work to a subagent so its material never fills the orchestrator's context
    Evidence: [Implementation](https://agentic-atlas.dev/nodes/session-bill#implementation-the-six-shifts) · occurrence 4

[↑ back to the top](https://agentic-atlas.dev/nodes/subagent-offload#content) [← the survey](https://agentic-atlas.dev/atlas)

Node subagent-offload · corpus 78c0e17 · Catalog revision e0cb75881244b1a82193ca738b82a0d508dd62e822524ae82873ec79d51dbb61