### Preflight Checklist - [x] I have searched [existing requests](https://github.com/anthropics/claude-code/issues?q=is%3Aissue%20label%3Aenhancement) and this feature hasn't been requested yet - [x] This is a single feature request (not multiple features) ### Problem Statement Title: Feature Request: Continuous conversation mode with background agent orchestration

Continuous conversation mode with background agent orchestration

Resolved 💬 3 comments Opened Feb 6, 2026 by emanblue Closed Feb 9, 2026

Preflight Checklist

[x] I have searched existing requests and this feature hasn't been requested yet
[x] This is a single feature request (not multiple features)

Problem Statement

Title:
Feature Request: Continuous conversation mode with background agent orchestration

Labels: enhancement, agent-teams, ux

---
Body:

## Summary

Enable continuous conversation with Claude while background agents execute tasks,
rather than blocking until all agents complete. Proposed architecture: front-facing
agent maintains conversation, supervisor orchestrates workers in background, and can
direct the front agent based on worker progress.

## Current Behavior

When dispatching multiple agents in parallel:

User requests work that requires multiple agents
Claude (Sonnet) launches agents using Task tool
Conversation blocks until all agents return results
Claude synthesizes results and responds
Conversation resumes

Example from recent session:
User: "Launch agents to audit Projects, Areas, Resources, Skills, and CLAUDE.md"
Claude: [Launches 5 Haiku agents]
Claude: [Waits 2-5 minutes for all to complete]
Claude: [Returns with compiled results]

Problem: User is idle during agent execution. No ability to ask questions,
provide clarifications, or shift priorities while work is in progress.

## Desired Behavior

Continuous conversation during agent execution:

User requests complex work
Claude launches agents and immediately resumes conversation
User can:

Ask clarifying questions
Discuss related topics
Receive real-time progress updates
Adjust priorities mid-execution

Agents complete in background
Results are integrated into ongoing conversation naturally

Example of ideal flow:
User: "Launch agents to audit the vault and process those YouTube bookmarks"

Claude: "Dispatching 6 agents now (Projects, Areas, Resources, Skills,
CLAUDE.md, Raindrop recovery). While they work, I noticed you
asked about MacBook performance earlier - want to discuss that?"

User: "Yeah, will M5 Pro Max help with Claude Code sessions?"

Claude: "Let me explain... [continues conversation]

Update: Projects agent just finished - found 3 overdue tasks
(Life Insurance, VA FMP, Apple Card). Want me to create a
quick-win package?

[conversation continues seamlessly]"
User: "Sure, and what about the YouTube bookmarks?"

Claude: "Raindrop agent reporting in - found your boot10 analysis.
25 bookmarks total, 76% are Claude lessons. I can process
those next or continue with vault audit - your call.

[all work completes in background without blocking conversation]"

## Proposed Architecture

### Three-Tier Pattern

┌─────────────────────────────────────────┐
│ User │
└─────────────┬───────────────────────────┘
│
▼
┌─────────────────────────────────────────┐
│ Front Agent (Sonnet/Opus) │
│ • Maintains continuous conversation │
│ • Explains what's happening │
│ • Gets clarifications in real-time │
│ • Reports progress as it occurs │
│ • Can be directed by Supervisor │
└─────────────┬───────────────────────────┘
│ (messaging)
▼
┌─────────────────────────────────────────┐
│ Supervisor (Opus) │
│ • Orchestrates all background work │
│ • Dispatches worker agents │
│ • Monitors progress │
│ • Reviews deliverables │
│ • Directs front agent on what to │
│ communicate/ask based on progress │
└─────────────┬───────────────────────────┘
│
┌───────┴───────┬─────────┬─────────┐
▼ ▼ ▼ ▼
[Haiku] [Haiku] [Haiku] [Haiku]
Worker 1 Worker 2 Worker 3 Worker 4

### Key Differences from Current Model

| Current | Proposed |
|---------|----------|
| Single Sonnet does conversation + orchestration | Separate front agent (conversation) + supervisor
(orchestration) |
| Conversation blocks during agent execution | Conversation continues during agent execution |
| Results returned all-at-once | Results integrated progressively |
| No mid-execution clarifications | Real-time user input possible |
| User waits during work | User stays engaged |

## Use Cases

### Use Case 1: Long-Running Vault Audit
Current: User waits 3-5 minutes while 6 agents audit vault, gets results dump at end

Proposed: User continues discussing priorities, asking questions about findings,
adjusting scope while agents work. Supervisor surfaces urgent findings (e.g., "overdue
task detected") mid-conversation.

### Use Case 2: Research + Analysis
Current: User requests research on 25 YouTube videos, waits for all analysis to
complete, then discusses findings

Proposed: While agents analyze videos, user discusses other work. Front agent
reports: "Analysis showing 76% are Claude tutorials - want to prioritize those?"
User can redirect work mid-stream.

### Use Case 3: Multi-Session Work
Current: Long task requires multiple sessions. Each session blocks on agent execution.

Proposed: Supervisor maintains work queue across sessions. Front agent keeps user
updated on progress, gets input on priorities, allows seamless continuation.

## Technical Considerations

### What I Understand Exists

Per tool descriptions, Agent Teams feature exists but is gated:

TeammateTool - Peer-to-peer agent messaging
SendMessage - Agent communication primitives
spawnTeam - Team coordination

Question: Does Agent Teams already enable this pattern, but UX doesn't make it
obvious? Or does Agent Teams focus on worker coordination without the front agent pattern?

### What's Missing (If Not Already Supported)

Front agent as distinct role - Not just another worker, but conversation specialist
Non-blocking conversation - Front agent responds immediately while supervisor works
Progressive result integration - Results flow into conversation as available, not all-at-once
Supervisor → Front agent messaging - Supervisor can tell front agent what to communicate
Persistent supervisor - Maintains state across conversation, not just task execution

### Potential Implementation

Option 1: Native pattern in Claude Code

CLI recognizes supervisor mode
Spawns front agent + supervisor automatically
Routes user input to front agent, work requests to supervisor
Built-in progress reporting

Option 2: Agent Teams extension

Users manually configure front + supervisor + workers
TeammateTool enables coordination
Pattern documented as best practice
Users architect their own setup

Recommendation: Option 1 (native) for better UX. Option 2 (manual) is better than
current blocking behavior if Option 1 is complex.

## Workarounds Tried

Background agents:

Used run_in_background: true with Task tool
Problem: Still blocks on result retrieval, can't interleave conversation

Polling pattern:

Launch supervisor in background writing to file
Periodically check file for updates
Problem: Janky, lots of I/O overhead, not true async conversation

Parallel dispatch:

Launch all agents in single message
Problem: Still blocks until all complete, no progressive results

None of these achieve continuous conversation.

## Benefits

### For Users

Stay engaged during long-running tasks
Provide input mid-execution (clarify requirements, shift priorities)
Better UX - no idle waiting time
Natural conversation flow - feels like talking to team, not monolithic system

### For Claude Code

Differentiation - Unique UX compared to other AI coding assistants
Enabler for complex workflows - Makes multi-hour tasks tractable
Better resource utilization - User can work on other things during agent execution
Scalability - Architecture supports future enhancements (persistent agents, cross-session work)

## Related

Agent Teams feature (gated): Provides underlying coordination primitives
Task tool run_in_background: Partial solution, but blocks on retrieval
Multi-agent orchestration: Well-known pattern in distributed systems, applied to conversational UX

## Context

User environment:

Plan tier: [You'll need to fill in your plan - e.g., "Pro", "Team", "Enterprise"]
Current limitation: Agent Teams not available on plan
Recent session example: Boot11 - deployed 6 Haiku agents, compiled ~450-line work

continuity package, but conversation blocked during agent execution

## Questions for Maintainers

Does Agent Teams already support this pattern? If so, is there documentation?
Is continuous conversation mode on the roadmap?
Would this require CLI changes, or could it be implemented with current primitives?
Is there interest in making this a first-class pattern vs. user-configured?

---

Thank you for considering this enhancement. Happy to provide more details, test early
implementations, or contribute to documentation if this aligns with the roadmap.

Proposed Solution

## Proposed Architecture

### Three-Tier Pattern

Alternative Solutions

### Key Differences from Current Model

Priority

Critical - Blocking my work

Feature Category

CLI commands and flags

Use Case Example