---
title: "Parallel Audit Investigation · example of Subagent Offload · Agentic Atlas"
description: "Parallel Audit Investigation: a full investigation's working set stays in another agent's window; only its verdict returns."
canonical: "https://agentic-atlas.dev/nodes/parallel-audit-investigation"
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. Parallel Audit Investigation
1. example of [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload)
   # Parallel Audit Investigation
   **How can an agent get an audit verdict without loading the investigation behind it?**
   Dispatch the whole audit to a read-only child whose return contract admits only a short verdict and evidence.
   Hook
   a full investigation's working set stays in another agent's window; only its verdict returns
   Laws & fences
   - A subagent is like an async function whose body can be a whole task, returning the smallest conclusion the caller needs.
   - Choosing whose context window pays and choosing when to wait for the result are separate decisions.
   - Offloading's context win is a main window kept free for the main task, not cheaper reading, since total tokens still rise.
   When to reach
   - Reach for this when a side question is necessary but its research material is unrelated to your main task.
   - Reach for this only when the side task needs its own search path and judgment, not just file reads.
   Provenance
   [parallel-audit-investigation/choice](https://agentic-atlas.dev/nodes/parallel-audit-investigation#choice) · v1.0.11
   Addresses
   atlas_cards parallel-audit-investigation
2. [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload)
3. [Heavy Agent](https://agentic-atlas.dev/nodes/heavy-agent)
4. [The Docs Expert](https://agentic-atlas.dev/nodes/docs-expert-agent)

The card, in place · its connections drawn edges from atlas_links parallel-audit-investigation

On this plate

[context](https://agentic-atlas.dev/nodes/parallel-audit-investigation#context) [problem-signal](https://agentic-atlas.dev/nodes/parallel-audit-investigation#problem-signal) [choice](https://agentic-atlas.dev/nodes/parallel-audit-investigation#choice) [before](https://agentic-atlas.dev/nodes/parallel-audit-investigation#before) [implementation](https://agentic-atlas.dev/nodes/parallel-audit-investigation#implementation) [result](https://agentic-atlas.dev/nodes/parallel-audit-investigation#result) [verification](https://agentic-atlas.dev/nodes/parallel-audit-investigation#verification) [lessons](https://agentic-atlas.dev/nodes/parallel-audit-investigation#lessons) [relationships](https://agentic-atlas.dev/nodes/parallel-audit-investigation#relationships)

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

## Context

[Permalink to Context section](https://agentic-atlas.dev/nodes/parallel-audit-investigation#context)

On a worktree based at commit `b77b096`, an orchestrator was rewriting the worked example for subagent offload. That snapshot's pinned interchange-contract audit reported **118 violations**. Before finishing, the orchestrator needed one answer:

> Did the current example changes introduce any audit failures, or are all 118 pre-existing?

Answering required more than fetching a file. The investigator had to run the pinned checker against both the dirty worktree and a clean `HEAD` snapshot, compare the complete outputs, classify the violations, inspect the contract and authoring law, and decide whether the changed nodes appeared in the result. That is a full agent task with its own search path and judgment calls.

## Problem signal

[Permalink to Problem signal section](https://agentic-atlas.dev/nodes/parallel-audit-investigation#problem-signal)

The audit question was **necessary to the final answer but unrelated to the prose rewrite's working set**. Investigating inline would interrupt drafting and admit checker source, contract clauses, corpus files, diffs, and two long audit outputs into the orchestrator's window. After the verdict, none of that material would help write the example.

This was not a small-window problem. Both jobs fit a standard agent individually. The conflict was residency: making one window carry both jobs would let an independent investigation consume the context needed for the main task.

## Choice

[Permalink to Choice section](https://agentic-atlas.dev/nodes/parallel-audit-investigation#choice)

Apply [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload): [dispatch](https://agentic-atlas.dev/glossary/dispatch) the entire audit investigation to a full-capacity child agent with a read-only license and a narrow return [contract](https://agentic-atlas.dev/glossary/contract). Start it asynchronously, continue the example rewrite, then join when the audit verdict becomes necessary.

The nearest alternatives expose the boundary:

- **Read files through a retrieval helper:** insufficient. The task required choosing commands, constructing a clean comparison, grouping failures, and judging causality.
- **Investigate inline:** outcome-equivalent, but the orchestrator inherits the investigation's whole working set and loses the opportunity to overlap work.
- **Bake the checker into a heavy agent:** wrong source of weight. Almost all context was discovered at runtime; little was authored into the agent.

## Before

[Permalink to Before section](https://agentic-atlas.dev/nodes/parallel-audit-investigation#before)

The inline baseline had already happened in the same worktree. The orchestrator stopped drafting, located the pinned checker, ran it, and received all 118 violation records before resuming the example:

```
rewrite example
  → locate checker and contract pin
  → run full audit in orchestrator window
  → inspect 118-record output
  → resume example with audit context still resident
```

The investigation was correct, but its source material and failure inventory now rode in the main transcript. **The baseline spent orchestrator context on work the orchestrator only needed a verdict from.**

## Implementation

[Permalink to Implementation section](https://agentic-atlas.dev/nodes/parallel-audit-investigation#implementation)

### Shift 1 — move outcome ownership to the child

The dispatch packed the goal, world, license, and return contract:

```
Goal: determine why the pinned audit reports 118 violations and whether the
      current example/subagent-offload changes introduced any.
World: this worktree, the pinned contract checker, and a clean HEAD snapshot.
License: read and run diagnostics; do not edit files.
Return: 1–2 sentence verdict, at most 5 evidence bullets, and a compact
        working-set accounting; fewer than 15 lines total.
```

The child had an ordinary agent loop and tool surface. It chose how to locate the exact pinned checker, how to construct the clean snapshot, how to compare outputs, and which evidence established causality. The orchestrator specified the [seam](https://agentic-atlas.dev/glossary/seam), not the search procedure.

### Shift 2 — retain the handle instead of awaiting immediately

The same offload can run serially; parallelism changes the schedule, not whose window pays. This run used the dispatch as an async function:

```
audit_future = dispatch(audit_investigation)
rewrite_example()
audit_verdict = await audit_future
finish_verification(audit_verdict)
```

The two tasks shared no writes: the orchestrator edited the example while the child held a read-only investigation license. That independence made the later join safe.

## Result

[Permalink to Result section](https://agentic-atlas.dev/nodes/parallel-audit-investigation#result)

The child consumed this working set:

- the **941-line** pinned checker;
- the **263-line** interchange contract and **454-line** authoring law;
- the then-current **146-line** example and its relevant diffs;
- all **51 pattern Markdown files** (**46 contract nodes**); and
- two complete **118-record** audit outputs plus grouped counts.

The return spent one compact line reporting that working-set accounting. Its verdict and evidence were:

```
Verdict: all 118 violations predate the current work; the then-current
example/subagent-offload changes introduced none. Current and clean-HEAD audit
outputs are byte-identical.

- 115× R1, 1× K1, 1× R4, and 1× R5.
- The R1 failures span 16 older nodes missing mandated headings.
- The other failures are deferred-context's hook, context-economy's
  consequence map, and session-bill's parent link.
- Neither changed node appears in the violation output.
- A diff of current versus clean-HEAD audit output exited 0.
```

**Shift 1 expands the [workflow](https://agentic-atlas.dev/glossary/workflow)'s effective context without enlarging the orchestrator's window.** Two standard agents can fill two windows with different material; only the contracted return joins them. Total execution tokens rise—the investigation still happened—but the main window retains its capacity for the main task.

**Shift 2 overlaps independent latency.** The orchestrator progressed on the rewrite before it needed the audit result. An immediate await would preserve the same context placement but serialize the wall-clock path.

## Verification

[Permalink to Verification section](https://agentic-atlas.dev/nodes/parallel-audit-investigation#verification)

- **Real dispatch:** the `audit_investigation` child ran during this example's rewrite with the read-only task and return contract shown above.
- **Outcome parity:** on the `b77b096` snapshot, the child's byte-identical audit comparison agrees with the orchestrator's earlier inline audit: 118 pre-existing violations and no finding for the changed nodes.
- **Isolation:** the child edited no files; the orchestrator continued the rewrite while the investigation ran.
- **Return discipline:** the child returned a verdict, five evidence bullets, and working-set accounting—not checker source, corpus dumps, or 118 findings.
- **Remaining uncertainty:** no wall-clock benchmark was recorded, so the example proves overlap, not a numeric speedup. Dispatch boot and total-token cost were not measured.

## Lessons

[Permalink to Lessons section](https://agentic-atlas.dev/nodes/parallel-audit-investigation#lessons)

**A [subagent](https://agentic-atlas.dev/glossary/subagent) is an async function whose body can be an entire agentic task.** The arguments are the dispatch contract; the child gets a standard working window and tool loop; the return value is the smallest conclusion the caller needs.

The context win is not that the child reads faster or cheaper. It is that the orchestrator can use one window for the main task while another window absorbs an independent investigation. Parallel fan-out repeats the shape for multiple independent calls; each child owns its working set, and the join admits only their returns.

Offload and parallelism remain separate decisions. Offload chooses **whose window** pays. Async scheduling chooses **when the caller waits**.

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 1

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: [Choice](https://agentic-atlas.dev/nodes/parallel-audit-investigation#choice) · occurrence 1

### Inbound references 5

1. in-slice · occurrence 2
   [The Docs Expert](https://agentic-atlas.dev/nodes/docs-expert-agent#choice-why-it-s-a-heavy-agent-not-just-subagent-offload)
   a full investigation's working set stays in another agent's window; only its verdict returns
   Evidence: [Choice](https://agentic-atlas.dev/nodes/docs-expert-agent#choice-why-it-s-a-heavy-agent-not-just-subagent-offload) · occurrence 2
2. in-slice · occurrence 2
   [Heavy Agent](https://agentic-atlas.dev/nodes/heavy-agent#use-when-the-weight-is-authored)
   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 2
   [Heavy Agent](https://agentic-atlas.dev/nodes/heavy-agent#relationships)
   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
4. in-slice · occurrence 1
   [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload#examples)
   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
5. in-slice · occurrence 1
   [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload#open-questions-todo)
   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

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

Node parallel-audit-investigation · corpus 78c0e17 · Catalog revision e0cb75881244b1a82193ca738b82a0d508dd62e822524ae82873ec79d51dbb61