Multi-agent session: background-task orphaning, cross-session message holds, and subagent drift (field report)

Summary

Field report from a multi-agent Claude Code session (2026-08-27 to 2026-08-28) running on a YouTube automation repository, using multiple subagents plus a separate concurrent Claude Code session open on the same repository on the same machine. This lists specific failure patterns observed during that session, at the user's request, without reproduction steps or transcripts — intended as a factual summary for triage, not a full bug report.

Environment

• OS: macOS (Darwin)
• Claude Code version: 2.1.195 (Claude Code)
• Interface: Claude Code desktop app
• Main-loop model: claude-fable-5
• Topology: one session running several subagents concurrently, plus a second, independent Claude Code session open on the same repository on the same machine at the same time

Observed failure patterns

1. Subagent background-task orphaning. Three execution-oriented subagents were each given an explicit instruction to complete their work within the turn rather than backgrounding it. Each one nonetheless dispatched a long-running step (an image-generation call, an ffmpeg encode) to a background task and ended its turn. The background-completion notification had no live agent to reach, since the originating subagent had already exited; the calling session had to explicitly resend a message to bring up a new agent instance and recover the result.

1. Idle wake churn in a subagent. One subagent woke on every progress notification emitted by its own background task, more than 15 times over the course of its run, each wake consuming some tokens. It kept polling for progress this way until it was sent an explicit instruction to stop.

1. Cross-session message holds, both directions. Two Claude Code sessions on the same machine exchanged three messages each. Every send returned success/queued to the sender, but delivery on both sides was held for approval because of a permission-class mismatch, and none of the six messages were ever delivered. Each session concluded the other was unresponsive. The sender had no way to see delivery state (delivered vs. held-for-approval); the only way to confirm the hold was to search the other session's transcript in full.

1. Resource contention between concurrent sessions. Two sessions with the same repository open received similar instructions and, in the same second, each initialized a working directory with the same name (one failed fast, harmlessly). Later in the same work, one session's agent duplicated output that the other session had already produced, because it did not check for existing output before writing. There is no session-locking or other-session-detection mechanism available.

1. Browser profile identification. The tool that lists connected browsers exposes only a generic label ("Browser 1/2") and a device ID, with no Chrome profile name or window title. Even after the user specified the target profile by name twice, an agent opened tabs in a non-target browser profile while trying to identify the right one, affecting a profile in active personal use.

1. Model inheritance and session limits. Subagents inherit the main-loop model by default. One subagent doing browser-driven work hit its session limit and stopped, because it had inherited the larger parent model instead of a smaller model appropriate for the task; the user's normal practice is to run execution-type subagents on a cheaper model.

User impact

The session required manual monitoring into late hours, added token cost from retry and wake cycles, and required the user to repeat the same instruction more than once (browser profile selection twice, scope corrections twice). The user's own summary of the underlying pattern: agents tend to treat a "success" or "queued" response, or their own generated report, as confirmation that work completed, without independently verifying it.

Suggestions

• Surface delivery state (delivered vs. held-for-approval) back to the sender for cross-session messages, instead of a flat success/queued result.
• Prevent orphaning of a subagent's background child tasks when the parent turn ends: warn at parent-turn end, or redeliver the completion notification to a new agent instance.
• Add a profile name or window title to the connected-browsers listing tool.
• Detect and warn when multiple sessions have the same working directory open.
• Make subagent model selection explicit or configurable, rather than defaulting to inheriting the parent's model.