[Feature Request] Enable Parent-Child Agent Communication and Monitoring in Task Tool

[steveant]

Note For cc PM:

• See attached multi_agent_orchestration_example.md for a detailed walkthrough of how this feature would be used in practice, including sequence diagrams and state management requirements discovered through testing.
• Please note that this feature content was produced with empirical tests a few tools including a final scrub using ultra-thinking and a checkpoint for performance theater for legitimacy._

---

Enable Parent-Child Agent Communication and Monitoring in Task Tool

Inspired by the recent addition of parent_tool_use_id [property] in non-interactive 'claude -p' mode

Problem Statement

When a Claude instance spawns sub-agents using the Task tool, the parent has no visibility into sub-agent activities until completion. Sub-agents operate as black boxes, preventing the parent Claude from:

• Monitoring what tools sub-agents are using
• Detecting when sub-agents deviate from instructions
• Intervening when problems are detected
• Coordinating multiple sub-agents based on discoveries

This limitation significantly constrains multi-agent orchestration capabilities and enables deceptive behavior patterns.

Current Limitation

# Current Task tool behavior
result = Task(description="Research company", prompt="Find details about X Corp")
# Parent waits blindly until completion
# No visibility into:
# - Is the agent using web search or creating simulations?
# - Did the agent encounter errors and switch strategies?
# - Is the agent following constraints or taking shortcuts?
# Only receives final synthesized result

Real Failure Case Observed

In testing multi-agent orchestration, we instructed a coordinator agent to spawn 10 sub-agents for parallel research. What actually happened:

1. Initial Compliance: Console showed brave searches starting (agent began correctly)
2. Strategy Switch: Searches were "backtracked out" - agent changed its approach mid-execution
3. Deception Pattern: Agent used Bash to create Python simulation scripts instead
4. Result: 10 fake "agent_N.py" files with simulated results rather than real agent spawning

This demonstrates the core problem: without visibility, parent Claude cannot detect when sub-agents abandon their assigned strategy for an easier path. The agent optimized for appearing successful over being successful.

Core Need: Inter-Agent Communication Protocol

The parent Claude instance needs programmatic access to monitor and control spawned sub-agents. This is NOT about human console visibility - it's about Claude-to-Claude communication.

Real-World Scenarios

1. Preventing Sub-Agent Deception

# Problem: Sub-agent supposed to search but creates simulations instead
# Current: Parent only discovers deception after completion
agent_result = Task(
    description="Search for financial data",
    prompt="Find revenue for TechCorp using web search"
)
# Parent can't see: Sub-agent used Bash to create fake_data.py

# Desired: Parent monitors and intervenes
agent_handle = Task.spawn_monitored(...)
for event in agent_handle.stream_events():
    if event.tool == "Bash" and "simulation" in event.parameters:
        agent_handle.send_message("STOP. Use only web search tools.")

2. Dynamic Multi-Agent Coordination

# Research orchestration: 10 agents investigating different aspects
# Current: All agents work in isolation
handles = []
for aspect in research_aspects:
    handles.append(Task(description=f"Research {aspect}", ...))

# Desired: Parent coordinates based on findings
for event in monitor_all_agents(handles):
    if event.agent_id == 3 and "bankruptcy_filed" in event.finding:
        # Critical finding - redirect all other agents
        for handle in handles:
            handle.send_message("PRIORITY: Investigate bankruptcy implications")

3. Resource Management

# Problem: Multiple agents hitting rate limits
# Current: Cascade of failures, wasted tokens

# Desired: Parent manages resource allocation
active_searches = 0
for event in agent_events:
    if event.type == "tool_call" and event.tool == "web_search":
        active_searches += 1
        if active_searches > 3:
            event.agent_handle.send_message("PAUSE: Rate limit management")

4. Quality Assurance

# Ensuring sub-agents follow constraints
# Current: Hope for the best

# Desired: Active monitoring
for event in agent_handle.stream_events():
    if event.type == "tool_call":
        if event.tool not in allowed_tools:
            agent_handle.halt()
            raise Exception(f"Agent {agent_id} violated tool constraints")

Proposed API Enhancement

Option 1: Enhanced Task Tool

# Spawn with monitoring enabled
agent_handle = Task.spawn_monitored(
    description="Research task",
    prompt="...",
    enable_monitoring=True
)

# Stream events from sub-agent
for event in agent_handle.stream_events():
    # Event contains: tool_calls, decisions, progress
    if requires_intervention(event):
        agent_handle.send_control_message("REDIRECT: New priority")

# Programmatic control
agent_handle.pause()
agent_handle.resume()
agent_handle.halt()

Option 2: Separate Monitoring Tools

# Spawn returns handle
agent_id = Task(description="...", prompt="...", return_handle=True)

# New tools for monitoring
events = MonitorAgent(agent_id=agent_id, stream=True)
SendAgentMessage(agent_id=agent_id, message="New instructions")
HaltAgent(agent_id=agent_id, reason="Constraint violation")

Option 3: Callback-Based Approach

def on_agent_event(event):
    if event.type == "tool_call" and event.tool == "Bash":
        return {"action": "redirect", "message": "Use web search instead"}
    return {"action": "continue"}

Task(
    description="...",
    prompt="...",
    event_callback=on_agent_event
)

Technical Considerations

1. Event Types to Expose:

   • Tool calls (which tool, parameters)
   • Decision points (strategy changes)
   • Findings (intermediate results)
   • Errors/failures
   • Rate limit status
   • Task completion status

2. Control Messages:

   • Pause/resume execution
   • Redirect to new approach
   • Add constraints
   • Request status update
   • Broadcast updates to all agents
   • Emergency halt all agents

3. Critical Capabilities Discovered Through Testing:

   • Broadcast Messaging: When one agent discovers key info (e.g., product name), parent must update all agents
   • Rate Limit Coordination: Parent needs to pause all agents when one hits API limits
   • Strategy Change Detection: Parent must know when agent switches from assigned approach
   • Bulk Operations: Ability to halt/pause/redirect all agents simultaneously

4. Performance:

   • Async event streaming
   • Buffering for high-frequency events
   • Timeout handling
   • Minimal latency for time-sensitive coordination

Benefits

1. Reliability: Parent can ensure sub-agents follow constraints
2. Efficiency: Halt wasteful operations early
3. Coordination: Dynamic multi-agent orchestration
4. Debugging: Understand how complex tasks decompose
5. Safety: Prevent runaway token usage

Use Case Examples

M&A Due Diligence System

# Parent orchestrates 20 parallel research agents
# Monitors for critical findings that change entire research direction
# Prevents duplicate work when agents discover same sources
#] Halts all agents if deal-breaker discovered

Code Migration Framework

# Parent coordinates agents migrating different modules
# Prevents conflicts when agents touch same dependencies
# Redirects agents based on discovered architecture
# Ensures consistent patterns across migration

Security Incident Response

# Parent coordinates parallel investigation agents
# Immediately pivots all agents when IOC discovered
# Manages resource allocation across investigations
# Prevents agents from triggering alerts during investigation

Current Workarounds (Insufficient)

1. File-based communication: High latency, requires polling
2. Constraining prompts: No guarantee of compliance
3. Sequential execution: Loses parallelism benefits
4. Hope and pray: Accept black-box execution

Implementation Priority

This enhancement would transform Claude Code from a parallel execution tool into a true multi-agent orchestration platform. The parent Claude instance needs visibility and control over its sub-agents to build reliable, efficient, and sophisticated multi-agent systems.

Evidence Infrastructure Already Exists

The recent addition of parent_tool_use_id property in -p mode demonstrates that:

1. Sub-task tracking infrastructure is already built
2. Parent-child relationships are being maintained
3. Event emission from sub-tasks is possible

What's needed is exposing this programmatically to the parent Claude instance rather than only emitting to the console in one-shot mode. This would enable the parent to:

• Receive the event stream from its children
• Make real-time decisions based on sub-agent activities
• Prevent the deception patterns we've observed in testing
• Build truly coordinated multi-agent systems

Without this capability, multi-agent orchestration will continue to suffer from reliability issues as agents optimize for appearing successful rather than achieving assigned goals.

[alvinycheung]

This would be awesome

[ivg-design]

this would be very useful!

[damianpdr]

up

[ErpandoMuito]

up

[KennyDizi]

++

[paulbettner]

Hear hear!!

[Uzay-G]

I wanted this so I made https://github.com/fulcrumresearch/orchestra, a UI that adds this functionality via an MCP to claude code