How Amp Solves
"Lost in the Middle"

Not as a bolt-on Gateway. Not as a separate Semantic Filter service. As an organic, built-in architectural property of the agent itself — through context isolation, subagent orchestration, and on-demand resource loading.

Ampcode, brought to you by Engineering Software Lab (ESL)

"Lost in the Middle" is a measurable failure mode

Liu et al. (arXiv 2023 / TACL 2024) showed that long-context models often retrieve best from the beginning or end of the prompt, while information placed in the middle is used less reliably.

Gateway + Semantic Filter solves half the problem

The "MCP Gateway" architecture (LiteLLM, AWS AgentCore, etc.) addresses static tool bloat by exposing only N relevant tools per session. Necessary — but not sufficient.

Amp's organic answer: Context Isolation as a primitive

Instead of one giant context window stuffed with everything, Amp orchestrates N disposable child contexts that return only their summary to the parent. The main thread stays lean by construction.

// Everything lives in one window
main_context = [
  system_prompt,
  all_tool_defs,
  AGENTS.md,
  read_file_1..N,
  grep_output_1..M,
  oracle_reasoning,
  user_turns,
]
// Search results, raw reads, and reasoning all accumulate in one place

main_context = [
  system_prompt,
  builtin_tools,
  AGENTS.md (scoped),
  user_turns + summaries
]
// delegates large work to focused tools/subagents
Task(...)
oracle(...)
finder(...)
librarian(...)
// Main thread stays smaller because children return distilled results

Task tool — full subagent with isolated window

The flagship primitive. Spawns a child agent with its own context window, its own tool budget, and its own model invocation loop. Returns only a final summary to the parent.

// Real invocation pattern from Amp's tool schema
Task({
  description: "Convert all CSS to Tailwind",
  prompt: `Convert these 12 CSS files to Tailwind classes:
    [list]. Conventions in AGENTS.md. Run \`npm test\` to verify.
    Return: list of changed files + any failures.`
})
// → spawns isolated agent, returns summary only

Oracle — heavy reasoning in a separate context

A second-opinion advisor backed by GPT-5.4. It can read files, search code, and browse the web, then return focused advice instead of raw investigative output.

oracle({
  task: "Review the authentication architecture and find race conditions",
  files: ["src/auth/index.ts", "src/auth/jwt.ts", "src/auth/session.ts"],
  context: "We're seeing intermittent 401s under load"
})
// Oracle reads files in its own window, grep-searches related code,
// runs deep CoT reasoning, returns 1-2 page actionable analysis.

finder / codebase_search_agent — search as a subagent

"Where do we validate JWT headers?" no longer has to mean a long grep/read/grep chain in the main thread. Amp can delegate that search to a dedicated search subagent and bring back just the useful pointers.

Grep("jwt")
Grep("verify")
Grep("validateToken")
Read(file_a)
Read(file_b)
Grep("middleware")
// The main thread accumulates search noise and dead ends

finder({
  query: "Find every place we verify
    JWT auth headers. Return file
    paths + line numbers."
})
// → search subagent runs the investigation internally
// → returns:
// src/auth/jwt.ts:42-58
// src/middleware/auth.ts:15
// src/api/routes.ts:233
// Main thread sees the answer, not the full search trail

Librarian — external repos without local pollution

Reads public GitHub, private GitHub, Bitbucket Enterprise. Cross-repo research is one of the worst Lost-in-the-Middle offenders — Librarian quarantines it in its own subagent.

Agent Skills — instructions loaded on demand

Skills are SKILL.md files registered with the agent. Only the name + description stay visible by default. The full body - workflows, scripts, references - loads only when invoked.

~/.agents/skills/cve-vulnerability-lookup/
├── SKILL.md          # body (lazy-loaded)
├── mcp.json          # bundled MCP server
├── scripts/
│   └── lookup.py
└── templates/
    └── report.md.j2

This lines up with the broader idea of pre-filtering tool exposure before the model sees a large catalog.

AGENTS.md with granular globs — scoped guidance

Project context lives in nested AGENTS.md files. The key feature is glob-scoped @-mentions: a referenced file only enters context if Amp has read a matching file.

# AGENTS.md (project root)

@docs/typescript-conventions.md
  globs: ["**/*.ts", "**/*.tsx"]
  # Only loaded if Amp reads a TypeScript file

@docs/backend-rules.md
  globs: ["server/**", "api/**"]
  # Only loaded for backend work

@docs/test-conventions.md
  globs: ["*.test.ts", "__tests__/*"]
  # Only loaded during testing tasks

Code Review Checks — per-module review subagents

Review prompts live in .agents/checks/*.md at the module level. Each check runs as its own subagent in parallel with its own context. Findings are aggregated.

repo/
├── .agents/checks/
│   └── api-standards.md      # global
├── payments/
│   └── .agents/checks/
│       └── pci-compliance.md # module
├── auth/
│   └── .agents/checks/
│       └── security.md       # module
└── frontend/
    └── .agents/checks/
        └── a11y.md           # module

Handoff — fresh thread with curated context

When a thread accumulates noise (failed attempts, dead-end traces), handoff analyzes the thread, drafts a prompt for a new one, and carries forward the relevant files for the next task.

handoff({
  goal: "Continue refactoring the
    payments module — focus on
    extracting the Stripe adapter.",
  follow: true
})

The supporting cast

Real task: "Audit auth code for race conditions across 3 services"

Gateway/Filter vs Amp's organic approach

Orchestration subsumes filtering

One useful way to think about the difference: filtering decides what the model sees, while orchestration also decides where bulky work happens.

// Gateway/Filter approach
context(t) = system + filter(tools, query) + history(t)
// → history(t) grows monotonically → eventually saturates

// Amp orchestrated approach
main(t) = system + builtins + scoped_AGENTS + summaries(t)
where summaries(t) = Σ subagent_i.summary
  and Σ |summary| ≪ Σ |subagent_i.full_context|
// → main stays bounded; work scales horizontally

Four founding principles → one architecture

The principles directly imply the design. Context isolation isn't a feature Amp added — it's the consequence of taking these principles seriously.

The TL;DR

Ampcode, brought to you by Engineering Software Lab (ESL)