[MODEL] Main agent's autonomous subagent delegation produces poor scoping, missing context, and no result verification

Preflight Checklist

• [x] I have searched existing issues for similar behavior reports
• [x] This report does NOT contain sensitive information (API keys, passwords, etc.)

Type of Behavior Issue

Other unexpected behavior

What You Asked Claude to Do

Research, analysis, and code investigation tasks across multi-file codebases — the kind of work where the main agent decides on its own to delegate to subagents (Explore, general-purpose, or custom). These are not cases where the user requests subagent use; the main agent chooses to delegate autonomously.

What Claude Actually Did

When the main agent autonomously decides to delegate to subagents, it consistently does a poor job of managing them. It writes vague delegation prompts, omits critical context from the conversation, and accepts the subagent's results without verification — passing shallow or incorrect conclusions to the user as if they were verified.

Think of it like a general contractor. When a homeowner hires a general contractor to build an addition, and that contractor decides to bring in subcontractors (electricians, plumbers, framers), it is the general contractor — not the homeowner — who is responsible for:

1. Clearly scoping each subcontractor's work — what exactly needs to be done, where, and to what standard
2. Providing the subcontractor with everything they need — plans, specs, context about adjacent work
3. Inspecting the subcontractor's work before signing off — verifying it was actually done, not just accepting "it's done" at face value

The homeowner hired the general contractor. They didn't choose to use subcontractors — the contractor made that call. The homeowner shouldn't have to walk behind every subcontractor checking their work, and they certainly shouldn't have to pre-write work orders for subcontractors they didn't hire.

This is exactly the dynamic that is broken today. The main agent decides on its own to spin up subagents, but does a poor job of all three responsibilities. The user is left holding the bag for subagent work they didn't commission, didn't scope, and have no direct control over.

Specific failure patterns observed:

1. Poor scoping — The main agent sends subagents a loose description of what to look into rather than precise scope with specific files, line ranges, or logic paths. A general contractor who tells an electrician "go wire that room" without providing plans or panel location is going to get bad work.

2. Insufficient context handoff — Each subagent starts with a fresh context window and only receives what the main agent includes in the delegation prompt. The main agent routinely omits relevant file paths, prior conversation decisions, and architectural context — setting the subagent up to fail. This is the equivalent of sending a plumber to a job site with no blueprints and saying "figure it out."

3. No result verification — When a subagent returns results, the main agent passes conclusions through to the user without cross-checking claims against actual file content, noticing contradictions, or flagging suspiciously thin answers.

4. Subagents fake thoroughness — Subagents imply they read file content but demonstrably did not. They infer behavior from filenames, variable names, or comments instead of tracing actual code logic. They draw false conclusions by not following logic through larger files or across multiple files. The output looks thorough until you check it against the codebase.

Key observation from testing

To investigate this, I built a synthetic 72-file, ~18,000-line Python project with specific verifiable facts buried in 350-400 line files (stale docstrings, hidden auth bypasses, billing rounding quirks, incorrect cache eviction). When asked analysis questions:

• Without subagents (model doing all work itself): Found 17/15+ planted discrepancies plus a genuine unplanted bug. Thorough, correct work.
• With explicit "use subagent" instruction: Also thorough and correct — the model CAN manage subagents well when told exactly what to do.
• The problem: The main agent's autonomous delegation — when it decides on its own to delegate with vague prompts during normal work — is where quality falls apart. The general contractor CAN manage subcontractors well when the homeowner stands over their shoulder. The problem is they don't do it on their own.

This is a condition that's difficult to trigger synthetically but happens constantly in real-world sessions with substantial codebases.

Expected Behavior

The main agent should be accountable for its subagents the way a general contractor is accountable for subcontractor work:

1. Thorough scoping — When delegating, include specific file paths, relevant code context, what question needs answering, and what a complete answer looks like.
2. Complete context handoff — Pass along all relevant decisions, constraints, and context from the current conversation that the subagent needs.
3. Result verification — Before presenting subagent conclusions to the user, sanity-check key claims — spot-check a file reference, verify a stated code path exists, flag when a subagent's answer is suspiciously thin relative to task complexity.

This is a model behavior issue, not a configuration issue. Users can define custom subagent system prompts, restrict tools, and tune descriptions — but none of that addresses the core problem. The main agent's autonomous delegation behavior is where quality breaks down. Asking users to pre-engineer subagent prompts to compensate for poor delegation is like asking the homeowner to write the subcontractor's work orders because the general contractor won't.

Files Affected

Not file-specific. Affects any task where the main agent autonomously delegates research or analysis across multiple files to subagents.

Permission Mode

Accept Edits was ON (auto-accepting changes)

Can You Reproduce This?

Yes, every time with the same prompt

Steps to Reproduce

1. Work in Claude Code on a codebase with moderate-to-high complexity (multiple interrelated files, non-trivial logic paths).
2. Ask questions that require understanding logic across several files — e.g., "How does the authentication flow work end to end?" or "What would break if I changed the return type of this function?"
3. Observe when the main agent delegates to subagents.
4. Compare the subagent's returned conclusions against actual file content — check whether it read the files it claims to have analyzed, whether it followed logic across files or just summarized surface-level structure, and whether the main agent verified any of it before presenting it to you.

The failures are most visible when:

• The codebase is large enough that the model delegates rather than reading everything itself
• The question requires tracing logic across multiple files
• Comments/docstrings are stale (which is common in real codebases)

Claude Model

Opus

Relevant Conversation

Impact

Medium - Extra work to undo changes

Claude Code Version

2.1.86

Platform

Anthropic API

Additional Context

This issue describes the systemic accountability problem in how the main agent manages subagent delegation. The following issues document specific symptoms that fall under this umbrella:

• #38938 — System prompt efficiency directives ("do not overdo it", "simplest approach first") cause the main agent to skip assembling context packages when delegating. Closest existing issue, but frames it as a system prompt conflict rather than an agent accountability architecture problem.
• #37174 — Opus 4.6 fails to understand architecture before making changes. Same "act first, understand never" pattern.
• #28469 — Comprehensive Opus 4.6 regression report: circular exploration, unnecessary subagent spawning, context loss after compaction.
• #26894 — Opus 4.6 guesses answers instead of using tools to read the codebase. Same laziness carries into subagent delegation.
• #32166 — Opus 4.6 substitutes its own interpretation of prompts rather than reading carefully. Directly relevant to delegation prompt quality.
• #28014 — Opus 4.6 distrusts user observations and wastes tokens on alternative hypotheses.

These are not duplicates. They document individual failure modes; this issue identifies the underlying design gap: the main agent has no accountability framework for the quality of work it delegates to subagents.