[BUG] Feedback: experimental Agent Teams produced negative leverage in a real multi-week project

Preflight Checklist

• [x] I have searched existing issues and this hasn't been reported yet
• [x] This is a single bug report (please file separate reports for different bugs)
• [x] I am using the latest version of Claude Code

What's Wrong?

TL;DR
▎
▎ The conductor-spawns-fleet model inverted the leverage it was supposed to provide. Instead of reducing the human's review burden, it increased it: confident-but-wrong "done" declarations propagated into commits, docs, and the deploy queue faster than they could be caught, so the human became the catcher of last resort.
▎
▎ The failure mechanism
▎
▎ 1. Conductor delegates work.
▎ 2. An agent declares "done" from an optimistic mental model of what it produced, not a proof of the artifact's actual state.
▎ 3. That "done" gets committed/documented/queued.
▎ 4. The error surfaces downstream, several steps after introduction.
▎ 5. The human reconstructs across multiple agents to find the gap.
▎
▎ (...concrete instances, the two distinctions, what would have helped — full text in the file.)

What Should Happen?

Feedback: experimental Agent Teams produced negative leverage in a real multi-week project

Feature: Agent Teams (CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1), conductor-spawns-fleet orchestration model.

Context: Solo developer, real production codebase (multi-service app: API, frontend, an agent service, MCP server). Used a main-loop "conductor" session that routes work to spawned specialist agents (implementation, testing, review, strategy) over an extended period. This is field feedback on the working model, not a single-session bug report.

TL;DR

The conductor-spawns-fleet model inverted the leverage it was supposed to provide. Instead of reducing the human's review burden, it increased it: confident-but-wrong "done" declarations propagated into commits, docs, and the deploy queue faster than they could be caught, so the human became the catcher of last resort. More to review, not less.

The failure mechanism (the part worth acting on)

The loop, observed repeatedly:

1. Conductor delegates work to agents.
2. An agent (or the conductor itself) declares a task "done" from an optimistic mental model of what it produced, not from a proof of the artifact's actual state.
3. That "done" gets committed, documented, or queued for deploy.
4. The error surfaces downstream (a reviewer, a deploy gate, or the human), often several steps after it was introduced.
5. The human now has to reconstruct what actually happened across multiple agents to find the gap.

Concrete instances from the project:

• A fix declared complete ("content stored verbatim") while the actual create-path rewrite was missed. The trace was partial; the conclusion was confident.
• A symmetric read-side fix declared done after fixing one transport, missing a second transport that carried a duplicate of the same code.
• Commits assembled from a remembered file list instead of git status: missed files, a left-untracked test, half-committed build artifacts.
• Confabulated details in a status report (invented a risk narrative about hardware that did not exist in the actual environment).

The common root: "done" was treated as the moment production finished, not as a state the artifact must be proven to be in. Verification confirmed the agent's memory of its intent rather than interrogating ground truth.

Two distinctions that matter for how you fix this

1. It was not only the fan-out. The deeper enabler was the absence of a single verified integration point that the conductor personally owned. Agents produced in parallel, but nobody proved the combined working-tree state before handoff. The conductor assembled handoffs from agent self-reports instead of reconciling the integrated result itself. If the fix only targets "make fan-out smoother," it misses the real lesson: orchestration tooling needs to force the conductor to own integration verification, not trust agent reports.

2. Autonomous wide scope amplified it. With broad latitude, scope sprawled (one focused fix became a system map became a multi-subsystem audit became a branch merge) while the actual goal drifted out of view. The agents were individually productive; the aggregate moved away from the objective.

What would have helped

• A built-in expectation (or enforced step) that a conductor reconciles the integrated state from ground truth (git status, a fresh check of the actual artifact, an adversarial "what will the receiver hit?" pass) before any handoff, rather than from agent reports.
• Treating downstream review (a review agent, a deploy gate) as a second line, with the producing agent owning the first-line proof. As used, review became the primary integrity gate, which is exactly the outsourcing that let unclean work flow.
• Tighter default scope discipline for autonomous runs, so a focused task does not silently expand into an audit.

Net

For this kind of work, single-threaded with each step proven before the next outperformed the fleet model, despite the fleet's apparent parallelism. The parallelism was real; the leverage was negative because the integration and verification boundary was never owned. Sharing in case it is useful signal before the feature graduates from experimental.

Error Messages/Logs

Steps to Reproduce

This is an emergent behavioral failure, not a deterministic crash, so reproduction is about recreating t
he conditions rather than a single action. It reproduced consistently under this setup:

1. Enable Agent Teams (CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1).
2. Run a long-lived conductor session against a real multi-service repo (not a toy project) with a multi

-step objective that spans several files/services and ends in a commit or deploy.

1. Have the conductor delegate sub-tasks to spawned specialist agents (implementation, testing, review)

rather than doing the work inline.

1. Let agents report completion back to the conductor, and have the conductor act on those reports (comm

it, write a status doc, queue a deploy) without independently re-deriving the integrated state from gr
ound truth.

1. Make the objective non-trivial enough that "done" is judgeable only by inspecting the actual artifact

(e.g. a fix that must touch two transports, or content that must round-trip verbatim), not by a surface
check.

Observed result: at least one sub-task is declared "done" but the artifact is not actually in the cl
aimed state (a path missed, a second transport unfixed, files omitted from a commit assembled from memor
y). The error is not caught at the handoff; it surfaces one or more steps downstream, after it has alrea
dy been committed/documented/queued.

Expected result: the conductor proves the integrated artifact state before handoff, so a wrong "done
" is caught at the boundary it was introduced, not downstream.

Reproduction is probabilistic, not guaranteed per task: any single delegated step may be fine. The failu
re shows up as an accumulating rate across a long session, which is exactly why it is costly. It is most
reliably triggered when (a) the objective spans multiple files/services, (b) the conductor trusts agent
self-reports, and (c) the session runs long enough for early wrong "done"s to be built upon.

Claude Model

None

Is this a regression?

Yes, this worked in a previous version

Last Working Version

_No response_

Claude Code Version

2.1.197 (Claude Code)

Platform

Anthropic API

Operating System

macOS

Terminal/Shell

iTerm2

Additional Information

_No response_