Context is a finite, degrading resource. Every long interaction is a fight against three forces that erode the information your agent needs to do its job.

Progressive Summarization Risk

When context grows long, the system summarizes earlier turns. Concrete transactional facts — dollar amounts, dates, order numbers — get smoothed into vague descriptions. The exact data the agent needs to resolve an issue disappears.

The "Lost in the Middle" Effect

Models process information at the beginning and end of long inputs most reliably. Information buried in the middle of a large context window is more likely to be overlooked. If the customer's key complaint was stated in turn 14 of a 30-turn conversation, it's in the danger zone.

Tool Result Bloat

An lookup_order call returns 40+ fields — shipping carrier tracking events, warehouse codes, internal SKU data, tax breakdowns. The agent only needed 5 fields. Those 40 fields now sit in context, consuming tokens and diluting signal.

Across a multi-turn session with several lookups, this compounds: 200 irrelevant fields vs. 25 relevant ones.

Four techniques to counter the three threats. Each targets a specific failure mode.

Technique 1: The "Case Facts" Block

Extract critical transactional data into a separate structured block included in every prompt, outside of summarized history. The conversation can be condensed — the case facts block always stays intact.

case facts=== CASE FACTS ===
Customer: Jane Martinez, ID #4421
Issue 1: Order #8812 — charged $47.99, expected $39.99, placed March 3
Issue 2: Order #8840 — return requested, status: delivered March 7
Escalation: None requested
=== END CASE FACTS ===

For multi-issue sessions, this becomes a structured context layer — a living document that grows as new issues surface.

Technique 2: Trimming Tool Outputs

Post-process tool results before they enter context. Keep only the fields relevant to the agent's current role. A 40-field order object becomes 5 fields of signal.

Technique 3: Strategic Positioning

Counter the lost-in-the-middle effect with deliberate placement. Key findings summaries go at the beginning of aggregated inputs. Detailed results use explicit section headers. The case facts block sits at the top of the prompt.

Technique 4: Structured Subagent Outputs

Upstream subagents return structured data (key facts, citations, relevance scores) instead of verbose content and reasoning chains. Downstream agents with limited context budgets receive clean, compact inputs — not paragraphs of reasoning to parse.

Escalation isn't about difficulty — it's about authority boundaries. The curriculum defines three specific triggers.

The Three Legitimate Triggers

The "Let Me Help" vs. "Right Away" Distinction

Soft request: Customer says "I want to talk to a manager." The issue is a simple return. You get one offer to resolve. If they reiterate, escalate immediately. No second attempts.

Hard request: Customer says "Get me a human NOW." Escalate immediately. No investigation, no "let me just check." Emphatic demands are honored without delay.

Unreliable Escalation Proxies

The Policy Gap Pattern

Your policy covers price matching against your own site's pricing errors. Customer asks for a competitor price match. The policy says nothing about competitors. The agent should not apply existing policy by analogy — silence in the policy is a gap, and gaps belong to humans.

Multiple Customer Matches

Agent searches and finds two "Jane Martinez" accounts. The correct response is to ask for an additional identifier (zip code, email), not to pick one based on heuristics like "most recent order."

When a subagent fails, the coordinator needs enough context to make a smart decision — retry, fall back, proceed with partial results, or surface the gap to the user.

The Two Anti-Patterns

Access Failure vs. Valid Empty Result

This is the foundational distinction. A subagent gets nothing back — but why?

If the subagent returns "no results" for both cases, the coordinator can't distinguish them. Generic error statuses like "service unavailable" strip away decision-critical context.

Structured Error Context

json{
  "status": "error",
  "failure_type": "timeout",
  "what_was_attempted": "inventory check for SKU #4419",
  "partial_results": null,
  "retry_recommended": true,
  "alternatives": "check warehouse B system directly"
}

Coverage Annotations in Synthesis

When the coordinator assembles a response and one subagent failed, the output flags the gap explicitly: "Your order #8812 is eligible for return. Note: I wasn't able to check current inventory for a replacement — I can check again or connect you with a team member."

Same degradation problems, different domain. Claude Code explores a massive codebase — thousands of files, complex dependency chains. The context window fills with verbose discovery output, and early findings get lost.

Technique 1: Scratchpad Files

The agent maintains a file on disk recording key findings as it goes. When it needs to answer a question later, it reads the scratchpad first. Findings are on disk — not dependent on surviving in the context window.

scratchpad=== SCRATCHPAD: Project Architecture ===
Entry point:      src/main/App.java
Refund logic:     src/services/RefundCalculator.java
Dependencies:     PricingEngine, TaxService, InventoryClient
Tests:            tests/services/RefundCalculatorTest.java (47 cases)
Config:           refund thresholds in config/policies.yaml

Technique 2: Subagent Delegation

Instead of the main agent grepping through hundreds of files (filling its own context), it spawns subagents with isolated context windows:

Technique 3: Phase-Based Summarization

Summarize findings from Phase 1 before spawning subagents for Phase 2. Inject those summaries into the new subagents' initial context. They start with knowledge, not from scratch.

Technique 4: Crash Recovery with State Manifests

Each agent periodically exports its state to a known file location. A coordinator-level manifest tracks completion status across all agents. On resume, the coordinator loads the manifest and injects it into the restarted agent's prompt.

manifest=== RECOVERY MANIFEST ===
Phase:       dependency_mapping
Completed:  [architecture_scan, test_discovery]
In Progress: refund_flow_trace (agent_3)
Pending:    [api_endpoint_mapping, config_analysis]
Findings:   /scratchpad/findings.md

Technique 5: /compact

A practical Claude Code command. When context fills with verbose discovery output, /compact compresses it — reducing context usage so the session can continue. A pragmatic escape valve, not a replacement for the other techniques.

At scale, you need to know when to trust the model's output and when to route it to a human reviewer. Aggregate accuracy metrics can mask critical failures.

The Aggregate Metric Trap

You must validate accuracy by document type and field segment — not just overall. A single number can't tell you where the system is reliable and where it isn't.

Stratified Random Sampling

Pull samples from each document type and field category, including high-confidence extractions. This catches calibration drift (model becomes overconfident on new formats) and detects novel error patterns not in the original validation set. This is ongoing, not one-time.

Field-Level Confidence Scores

Instead of one score per document, the model outputs a score per field. A low score on "total amount" routes just that field to human review, even if the rest looks fine.

Routing Review Attention

When multiple subagents gather information from different sources, the synthesis agent must combine it without losing track of where things came from.

The Provenance Problem

Subagent A: market size is $4.2B (industry report, 2023). Subagent B: market size is $3.8B (government dataset, 2021). Synthesis agent writes: "The market size is approximately $4 billion."

Three failures: source attribution gone, temporal context gone, conflict silently resolved by averaging.

Structured Claim-Source Mappings

Each subagent returns findings tied to their source — URL, document name, publication date, methodology. The synthesis agent must preserve these mappings through the final output.

json{
  "claim": "Market size is $4.2B",
  "source": "Gartner Industry Report 2023",
  "source_url": "https://...",
  "publication_date": "2023-06-15",
  "methodology": "Survey of 500 enterprises"
}

Conflicts: Annotate, Don't Arbitrate

Temporal Context Prevents False Contradictions

The $3.8B (2021) and $4.2B (2023) figures might not conflict at all — they could reflect market growth. Without publication dates in the structured output, the synthesis agent treats them as contradictory claims about the same point in time. Requiring dates in subagent outputs prevents this specific class of misinterpretation.

Rendering by Content Type

The synthesis output should match the nature of the content: financial data as tables, news as prose, technical findings as structured lists. Don't flatten everything into one uniform format — that loses information and readability.

Report Structure