--- title: "Heavy Agent · Agentic Atlas" description: "Heavy Agent: the authored-heavy specialization." canonical: "https://agentic-atlas.dev/nodes/heavy-agent" last-updated: "2026-08-19" --- # Heavy Agent · Agentic Atlas [← the survey](https://agentic-atlas.dev/atlas) 1. pattern Heavy Agent Hook the *authored-heavy* specialization Thesis A heavy agent bakes the extensive instructions and expertise a task needs into an agent definition that the orchestrator invokes by type, so the heavy context materializes in the subagent's own window and the orchestrator, which references the agent rather than loading it, never pays for it. Laws & fences - Applying it as a heavy agent is one decision: the weight goes in the definition, not in the dispatch, so instructions, rubric, and reference are authored once into the agent file and the orchestrator then carries the type name and a narrow task. - Heavy agent ends at the offload; what comes back, how it is shaped, and whether it is checked are separate concerns owned by neighbor patterns, which it names as the boundary without reaching into them. - Baked-in expertise is a standing surface, not a per-run cost: a baked-in reference can drift out of date, and the orchestrator, which never loads the definition, never sees it age. - Isolation cuts both ways: everything the subagent needs must be packed into the dispatch prompt because it cannot see the orchestrator's working context, and the orchestrator cannot watch or steer the work mid-flight, trading visibility and steerability for the context relief. When to reach - Reach for it when a task needs a lot of context to do well, such as detailed instructions, domain expertise, or large reference material, and carrying that weight in the orchestrator's own window would fill it up and degrade or kill a long workflow. - Skip it when the weight is runtime rather than authored, with nothing baked into a definition and the material swept and discarded per run; the branch baseline already covers that case. Provenance [heavy-agent/intent-the-problem-and-the-move](https://agentic-atlas.dev/nodes/heavy-agent#intent-the-problem-and-the-move) · v1.0.2 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) 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#intent-the-problem-and-the-move)[use-when-the-weight-is-authored](https://agentic-atlas.dev#use-when-the-weight-is-authored)[avoid-when-where-the-pattern-ends](https://agentic-atlas.dev#avoid-when-where-the-pattern-ends)[forces](https://agentic-atlas.dev#forces)[structure-the-parts-and-what-counts-as-the-weight](https://agentic-atlas.dev#structure-the-parts-and-what-counts-as-the-weight)[application](https://agentic-atlas.dev#application)[consequences-and-tradeoffs](https://agentic-atlas.dev#consequences-and-tradeoffs)[verification](https://agentic-atlas.dev#verification)[examples](https://agentic-atlas.dev#examples)[relationships](https://agentic-atlas.dev#relationships)[lineage](https://agentic-atlas.dev#lineage) [relationships](https://agentic-atlas.dev#relationships) Every section is addressable on its own. Read only the ground you need. ## Intentthe problem and the move [](https://agentic-atlas.dev#intent-the-problem-and-the-move) intent-the-problem-and-the-move.md 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 whenthe weight is authored [](https://agentic-atlas.dev#use-when-the-weight-is-authored) use-when-the-weight-is-authored.md 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 whenwhere the pattern ends [](https://agentic-atlas.dev#avoid-when-where-the-pattern-ends) avoid-when-where-the-pattern-ends.md 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 [](https://agentic-atlas.dev#forces) forces.md 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. ## Structurethe parts, and what counts as "the weight" [](https://agentic-atlas.dev#structure-the-parts-and-what-counts-as-the-weight) structure-the-parts-and-what-counts-as-the-weight.md 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 [](https://agentic-atlas.dev#application) application.md 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 [](https://agentic-atlas.dev#consequences-and-tradeoffs) consequences-and-tradeoffs.md - **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 `../../../../../foundations/llm-dispatch/llm-dispatch.md` → *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 [](https://agentic-atlas.dev#verification) verification.md 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 [](https://agentic-atlas.dev#examples) examples.md - [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 [](https://agentic-atlas.dev#relationships) relationships.md - **Parent — Subagent offload** (`../subagent-offload.md`): 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 (`../../../../../foundations/the-contract-keystone/the-contract-keystone.md`) for the return contract; context envelope (`../../../distillation/context-envelope.md`) for distilling the return; validated seam / re-dispatch (`../../../../../verification/validated-seam-redispatch.md`) for checking it. - Pairs with **durable state** (`../../../../../persistence/durable-state.md`) when handoff across dispatches must survive. ## Lineage [](https://agentic-atlas.dev#lineage) lineage.md 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 10 1. in-slice · occurrence 1 [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload) the *dispatch-elsewhere* branch 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 agent investigates in parallel; its working set stays elsewhere and only the 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) the *dispatch-elsewhere* branch 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) the *dispatch-elsewhere* branch 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) the *dispatch-elsewhere* branch Evidence: [Application](https://agentic-atlas.dev/nodes/heavy-agent#application) · occurrence 1 6. in-slice · occurrence 1 [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload) the *dispatch-elsewhere* branch Evidence: [Verification](https://agentic-atlas.dev/nodes/heavy-agent#verification) · occurrence 1 7. in-slice · occurrence 1 [The Docs Expert](https://agentic-atlas.dev/nodes/docs-expert-agent) a large reference baked into the agent; narrow questions in, distilled answers out — the orchestrator never loads the docs Evidence: [Examples](https://agentic-atlas.dev/nodes/heavy-agent#examples) · occurrence 1 8. in-slice · occurrence 1 [Parallel Audit Investigation](https://agentic-atlas.dev/nodes/parallel-audit-investigation) a full agent investigates in parallel; its working set stays elsewhere and only the verdict returns Evidence: [Relationships](https://agentic-atlas.dev/nodes/heavy-agent#relationships) · occurrence 1 9. in-slice · occurrence 2 [Reference Data](https://agentic-atlas.dev/nodes/reference-data) the *authored-heavy* specialization: disk-resident, grep-addressable — pay for the size of the answer Evidence: [Relationships](https://agentic-atlas.dev/nodes/heavy-agent#relationships) · occurrence 2 10. in-slice · occurrence 3 [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation) change when or whose window pays; may compose with selection or distillation Evidence: [Relationships](https://agentic-atlas.dev/nodes/heavy-agent#relationships) · occurrence 3 ### Inbound references 5 1. in-slice · occurrence 7 [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation#relationships) the *authored-heavy* specialization Evidence: [Relationships](https://agentic-atlas.dev/nodes/cost-relocation#relationships) · occurrence 7 2. 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) the *authored-heavy* specialization Evidence: [Choice](https://agentic-atlas.dev/nodes/docs-expert-agent#choice-why-it-s-a-heavy-agent-not-just-subagent-offload) · occurrence 1 3. in-slice · occurrence 2 [Reference Data](https://agentic-atlas.dev/nodes/reference-data#relationships) the *authored-heavy* specialization Evidence: [Relationships](https://agentic-atlas.dev/nodes/reference-data#relationships) · occurrence 2 4. in-slice · occurrence 1 [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload#consequences-and-tradeoffs) the *authored-heavy* specialization Evidence: [Consequences and tradeoffs](https://agentic-atlas.dev/nodes/subagent-offload#consequences-and-tradeoffs) · occurrence 1 5. in-slice · occurrence 4 [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload#relationships) the *authored-heavy* specialization Evidence: [Relationships](https://agentic-atlas.dev/nodes/subagent-offload#relationships) · occurrence 4 [↑ back to the top](https://agentic-atlas.dev#content) [← the survey](https://agentic-atlas.dev/atlas) Node heavy-agent · corpus 31de4cb · Catalog revision 35263c4c415da742953d0462804fb14424e2244dae4c63efd27e468988de70ab