---
title: "Heavy Agent · pattern · Agentic Atlas"
description: "Heavy Agent: subagents that carry heavy baked-in instructions the orchestrator never loads."
canonical: "https://agentic-atlas.dev/nodes/heavy-agent"
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](https://agentic-atlas.dev/nodes/subagent-offload)
5. Heavy Agent

Seen working in [The Docs Expert](https://agentic-atlas.dev/nodes/docs-expert-agent).

1. pattern
   # Heavy Agent
   **When should a specialist agent carry heavy instructions or a large reference in its own context?**
   Use a heavy agent when separable work needs extensive authored instructions, a domain rubric, or a large reference.
   Hook
   subagents that carry heavy baked-in instructions the orchestrator never loads
   Laws & fences
   - Put the heavy instructions, rubric, and reference in the agent definition, not in each dispatch.
   - Set the agent's model and effort level in its definition rather than silently inheriting the orchestrator's.
   - Isolation cuts both ways: the agent cannot see the orchestrator's context, and the orchestrator cannot steer it mid-flight.
   - Baked-in expertise has to be kept correct, and the orchestrator never sees it go stale.
   - The pattern covers only the offload, and shaping or checking the result belongs to other patterns.
   - Like any offload, the work's working set should dwarf the conclusion the orchestrator needs.
   When to reach
   - Reach for this when an orchestrator's window would fill with expertise for work it is not doing.
   - Reach for a plain subagent instead when the weight is material read and discarded at runtime.
   Provenance
   [heavy-agent/use-when-the-weight-is-authored](https://agentic-atlas.dev/nodes/heavy-agent#use-when-the-weight-is-authored) · v1.0.11
   Addresses
   atlas_cards heavy-agent
2. [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload)
3. [Parallel Audit Investigation](https://agentic-atlas.dev/nodes/parallel-audit-investigation)
4. [The Docs Expert](https://agentic-atlas.dev/nodes/docs-expert-agent)
5. [Reference Data](https://agentic-atlas.dev/nodes/reference-data)
6. [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation)
7. [The Contract Keystone](https://agentic-atlas.dev/nodes/the-contract-keystone)
8. [LLM Dispatch](https://agentic-atlas.dev/nodes/llm-dispatch)
9. [The Contract](https://agentic-atlas.dev/nodes/contract-documentation)
10. field notes
    - “the travelling declared-shape contract specialization”
    - “validate at the return seam; re-dispatch over repair; bounded autonomy — the contract keystone, applied”
    - “accumulated memory, a **separate concern from config**”

LLM DispatchThe Contract +1 more unfold the map fold the map

The card, in place · its connections drawn edges from atlas_links heavy-agent

On this plate

[intent-the-problem-and-the-move](https://agentic-atlas.dev/nodes/heavy-agent#intent-the-problem-and-the-move) [use-when-the-weight-is-authored](https://agentic-atlas.dev/nodes/heavy-agent#use-when-the-weight-is-authored) [avoid-when-where-the-pattern-ends](https://agentic-atlas.dev/nodes/heavy-agent#avoid-when-where-the-pattern-ends) [forces](https://agentic-atlas.dev/nodes/heavy-agent#forces) [structure-the-parts-and-what-counts-as-the-weight](https://agentic-atlas.dev/nodes/heavy-agent#structure-the-parts-and-what-counts-as-the-weight) [application](https://agentic-atlas.dev/nodes/heavy-agent#application) [consequences-and-tradeoffs](https://agentic-atlas.dev/nodes/heavy-agent#consequences-and-tradeoffs) [verification](https://agentic-atlas.dev/nodes/heavy-agent#verification) [examples](https://agentic-atlas.dev/nodes/heavy-agent#examples) [relationships](https://agentic-atlas.dev/nodes/heavy-agent#relationships) [lineage](https://agentic-atlas.dev/nodes/heavy-agent#lineage) [relationships-ledger](https://agentic-atlas.dev/nodes/heavy-agent#relationships-ledger)

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

## Intent — the problem and the move

[Permalink to Intent — the problem and the move section](https://agentic-atlas.dev/nodes/heavy-agent#intent-the-problem-and-the-move)

A task needs a lot of context to do well — detailed instructions, domain expertise, large reference material. If the orchestrator carries that weight in its own window, its context fills up and a long [workflow](https://agentic-atlas.dev/glossary/workflow) degrades or dies. The orchestrator's window becomes the bottleneck for work it isn't even doing itself.

The move: bake the heavy context — the extensive instructions and expertise a task needs — into an **agent definition**, and have the orchestrator **invoke it by type**. [Dispatching](https://agentic-atlas.dev/glossary/dispatch) by type is cheap: the orchestrator *references* the agent, it doesn't *load* it. The heavy instructions — and whatever the agent reads or reasons through at runtime — materialize in the **subagent's own** window, which the orchestrator never pays for. The orchestrator dispatches and waits; the weight lives elsewhere.

## Use when — the weight is authored

[Permalink to Use when — the weight is authored section](https://agentic-atlas.dev/nodes/heavy-agent#use-when-the-weight-is-authored)

The who-axis observables are the [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload)'s (*Use when*): the work is separable, and the working set dwarfs its conclusion. What types a task to *this* specialization rather than to the branch baseline is where the weight was put.

This is **subagent offload specialized by *authored* weight.** Plain subagent offload (e.g. [Parallel Audit Investigation](https://agentic-atlas.dev/nodes/parallel-audit-investigation)) offloads mostly *runtime* context — files swept, discarded after the answer. A heavy agent is the case where the defining weight is **baked into the agent file**: deep instructions, a domain rubric, a large reference. "Heavy" names the authored instruction set.

## Avoid when — where the pattern ends

[Permalink to Avoid when — where the pattern ends section](https://agentic-atlas.dev/nodes/heavy-agent#avoid-when-where-the-pattern-ends)

The who-axis contraindications are the [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload)'s (*Avoid when*) and they close this specialization with it; one more closes the specialization alone, and a scope boundary marks where the pattern stops rather than where it is wrong.

- **The weight is runtime, not authored.** Nothing is baked into a definition — the material is swept and discarded per run. The branch baseline already covers it; the Explore agent is the parent's example, not this node's case.

Heavy agent **ends at the offload**: it offloads required context, full stop. The orchestrator doesn't load the context, doesn't carry it at runtime, doesn't bring it into its window — it just dispatches, and the agent gets a context budget the orchestrator never had to pay. **That is the whole pattern.** What comes back, how it's shaped, and whether it's checked are *separate* concerns owned by neighbor patterns (the [contract](https://agentic-atlas.dev/glossary/contract), context envelope, validated seam). Heavy agent names them as the boundary; it does not reach into them.

## Forces

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

Isolation-as-price and the per-dispatch re-boot are the [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload)'s forces; both bind here unchanged, and their developed per-child form is *Consequences and tradeoffs* below. What authored weight adds is a pressure the branch baseline's runtime-heavy case never carries: **baked-in expertise is a standing surface, not a per-run cost.** The same authoring that makes an agent worth invoking by type also makes it something that has to be kept correct — and the orchestrator, which never loads the definition, never sees it age.

## Structure — the parts, and what counts as "the weight"

[Permalink to Structure — the parts, and what counts as "the weight" section](https://agentic-atlas.dev/nodes/heavy-agent#structure-the-parts-and-what-counts-as-the-weight)

The weight is the **total context cost to achieve the task** — not just the authored instructions but the tokens burned getting to the goal (reading, exploring, intermediate reasoning). All of it is borne in the subagent's window. The authored heaviness is what makes it a *heavy* agent specifically; offloading the runtime cost too is inherited from subagent offload.

- The **orchestrator** holds a lean context. It knows the agent *type* and a narrow task; it does not hold the agent's instructions or working material.
- The **dispatch** carries everything the isolated agent will need — it can't see the orchestrator's window.
- The **heavy agent** loads its baked-in weight plus whatever it reads at runtime, all in its own window, and does the work.
- The **[return](https://agentic-atlas.dev/glossary/return)** crosses back — the one cost the orchestrator can't defer. Keeping it smaller than the context it replaced is the job of the neighbor patterns, not this one.

## Application

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

The branch procedure holds unchanged — name the separable unit, author the function [pointer](https://agentic-atlas.dev/glossary/pointer), pack the dispatch by the primitive's checklist, declare what comes back ([Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload), *Application*). Applying it as a *heavy* agent is one decision: the weight goes in the **definition**, not in the dispatch. Instructions, rubric, and reference are authored once into the agent file; the orchestrator then carries the type name and a narrow task, and every invocation materializes the weight in the subagent's window. Pin the executor slot in that same definition — expertise the definition asserts is expertise the definition should price.

## Consequences and tradeoffs

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

- **Per-dispatch fixed cost.** Every dispatch spins up a fresh agent and re-pays its system prompt / boot context. There's no warm reuse across dispatches — invoke it N times and you pay that baseline N times, plus dispatch latency. Easy to forget when fanning out.
- **Isolation cuts both ways** *(the bigger real impact).* The subagent can't see the orchestrator's working context, so you must pack everything it needs into the dispatch prompt (the packing anatomy lives at [LLM Dispatch](https://agentic-atlas.dev/nodes/llm-dispatch) → *Model and claims › Packing the child's world*). And the orchestrator can't watch or steer the work mid-flight — it only sees the return. You trade visibility and steerability for the context relief.
- **The executor slot bites hardest here.** A heavy agent's definition can pin its own model and effort tier — expertise priced deliberately — while silence inherits the orchestrator's tier, price and dispositions unjudged (the slot and its default live at the primitive's dispatch anatomy).
- *(Authored-heavy agents specifically:)* a baked-in reference can drift out of date — the authored weight is a maintenance burden the orchestrator never sees.
- *(Boundary:)* the return is the one cost you can't defer; shaping and checking it is the neighbor patterns' job.

## Verification

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

The [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload)'s checks (*Verification*), read against authored weight.

- **Deterministic — the definition never entered the orchestrator.** The orchestrator's transcript carries the agent's type name, the dispatch, and the return; the baked-in instructions, and everything the agent read to reach its answer, appear in the subagent's transcript alone. Invocation by type either referenced the definition or loaded it, and the transcript settles which.
- **Probabilistic — packing sufficiency, and the weight's currency.** The parent's residue holds: an under-packed dispatch starves an agent that cannot see the orchestrator's window. Authored weight adds one of its own — a baked reference that has drifted produces stale work, and the orchestrator, which never reads the definition, sees only the return.

## Examples

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

- [The Docs Expert](https://agentic-atlas.dev/nodes/docs-expert-agent) — the docs expert: a large reference baked into the agent; the canonical *authored-heavy* case.

## Relationships

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

- **Parent — Subagent offload** ([Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload)): dispatch a subagent so its context is never yours. Heavy agent is the specialization where the subagent is heavy *by authored design*. [Parallel Audit Investigation](https://agentic-atlas.dev/nodes/parallel-audit-investigation) is the parent's runtime-heavy, lightly authored example.
- **The later/elsewhere split and the cross-branch rhyme** — mapping this node opposite [Reference Data](https://agentic-atlas.dev/nodes/reference-data) as each branch's authored-heavy case — **are owned at [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation)** (*Structure*).
- **Return neighbors (the boundary, not owned here):** the contract / the contract keystone ([The Contract Keystone](https://agentic-atlas.dev/nodes/the-contract-keystone)) for the return contract; context envelope (*the travelling declared-shape contract specialization*) for distilling the return; validated seam / re-dispatch (*validate at the return seam; re-dispatch over repair; bounded autonomy — the contract keystone, applied*) for checking it.
- Pairs with **durable state** (*accumulated memory, a **separate concern from config***) when handoff across dispatches must survive.

## Lineage

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

Facade and Proxy (Gang of Four): a Facade presents a simplified interface over a complex subsystem; a Proxy stands in for a resource and controls access to it. The expert/librarian distinction is that split drawn over context rather than code.

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 16

1. in-slice · occurrence 1
   [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload)
   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
2. in-slice · occurrence 2
   [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: [Use when](https://agentic-atlas.dev/nodes/heavy-agent#use-when-the-weight-is-authored) · occurrence 2
3. in-slice · occurrence 1
   [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload)
   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
4. in-slice · occurrence 1
   [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload)
   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
5. in-slice · occurrence 1
   [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload)
   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
6. 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: [Consequences and tradeoffs](https://agentic-atlas.dev/nodes/heavy-agent#consequences-and-tradeoffs) · occurrence 1
7. in-slice · occurrence 1
   [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload)
   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
8. in-slice · occurrence 1
   [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/heavy-agent#examples) · occurrence 1
9. in-slice · occurrence 1
   [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload)
   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
10. in-slice · occurrence 2
    [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: [Relationships](https://agentic-atlas.dev/nodes/heavy-agent#relationships) · occurrence 2
11. 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/heavy-agent#relationships) · occurrence 3
12. in-slice · occurrence 4
    [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/heavy-agent#relationships) · occurrence 4
13. in-slice · occurrence 5
    [The Contract Keystone](https://agentic-atlas.dev/nodes/the-contract-keystone)
    how contracts, cheap checks, and safe discards together make agent handoffs safe
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/heavy-agent#relationships) · occurrence 5
14. undisclosed · occurrence 6
    Undisclosed relationship
    the travelling declared-shape contract specialization
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/heavy-agent#relationships) · occurrence 6
15. 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/heavy-agent#relationships) · occurrence 7
16. undisclosed · occurrence 8
    Undisclosed relationship
    accumulated memory, a **separate concern from config**
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/heavy-agent#relationships) · occurrence 8

### Inbound references 7

1. in-slice · occurrence 4
   [The Contract](https://agentic-atlas.dev/nodes/contract-documentation#relationships)
   subagents that carry heavy baked-in instructions the orchestrator never loads
   Evidence: [Relationships](https://agentic-atlas.dev/nodes/contract-documentation#relationships) · occurrence 4
2. in-slice · occurrence 7
   [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation#relationships)
   subagents that carry heavy baked-in instructions the orchestrator never loads
   Evidence: [Relationships](https://agentic-atlas.dev/nodes/cost-relocation#relationships) · occurrence 7
3. in-slice · occurrence 1
   [The Docs Expert](https://agentic-atlas.dev/nodes/docs-expert-agent#choice-why-it-s-a-heavy-agent-not-just-subagent-offload)
   subagents that carry heavy baked-in instructions the orchestrator never loads
   Evidence: [Choice](https://agentic-atlas.dev/nodes/docs-expert-agent#choice-why-it-s-a-heavy-agent-not-just-subagent-offload) · occurrence 1
4. in-slice · occurrence 2
   [Reference Data](https://agentic-atlas.dev/nodes/reference-data#relationships)
   subagents that carry heavy baked-in instructions the orchestrator never loads
   Evidence: [Relationships](https://agentic-atlas.dev/nodes/reference-data#relationships) · occurrence 2
5. in-slice · occurrence 1
   [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload#consequences-and-tradeoffs)
   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
6. in-slice · occurrence 4
   [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload#relationships)
   subagents that carry heavy baked-in instructions the orchestrator never loads
   Evidence: [Relationships](https://agentic-atlas.dev/nodes/subagent-offload#relationships) · occurrence 4
7. in-slice · occurrence 3
   [The Contract Keystone](https://agentic-atlas.dev/nodes/the-contract-keystone#relationships)
   subagents that carry heavy baked-in instructions the orchestrator never loads
   Evidence: [Relationships](https://agentic-atlas.dev/nodes/the-contract-keystone#relationships) · occurrence 3

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

Node heavy-agent · corpus 78c0e17 · Catalog revision e0cb75881244b1a82193ca738b82a0d508dd62e822524ae82873ec79d51dbb61