langchain - 💡(How to fix) Fix Support Direct Conversation/Message Interaction for Subagents (Similar to OpenClaw’s Sub-Agent Session Feature) [1 participants]

Checked other resources

• This is a feature request, not a bug report or usage question.
• I added a clear and descriptive title that summarizes the feature request.
• I used the GitHub search to find a similar feature request and didn't find it.
• I checked the LangChain documentation and API reference to see if this feature already exists.
• This is not related to the langchain-community package.

Package (Required)

• langchain
• langchain-openai
• langchain-anthropic
• langchain-classic
• langchain-core
• langchain-model-profiles
• langchain-tests
• langchain-text-splitters
• langchain-chroma
• langchain-deepseek
• langchain-exa
• langchain-fireworks
• langchain-groq
• langchain-huggingface
• langchain-mistralai
• langchain-nomic
• langchain-ollama
• langchain-openrouter
• langchain-perplexity
• langchain-qdrant
• langchain-xai
• Other / not sure / general

Feature Description

I request adding direct conversation and message interaction capabilities to LangChain’s subagents, similar to the sub-agent spawning and session management features provided by OpenClaw (see OpenClaw Sub-Agent Session Documentation). Currently, LangChain’s subagents operate under centralized control by the main agent, with no ability to directly interact with the user—all communications between subagents and users must be routed through the main agent (as noted in LangChain Subagents Key Characteristics). This feature would enable LangChain subagents to:

• Initiate direct message requests to the user during task execution when additional information, confirmation, or clarification is needed (e.g., verifying a critical parameter, confirming a data source, or validating a step’s approach), without relying on the main agent as an intermediary.
• Receive direct user input (e.g., confirmations, corrections, or follow-up questions) and respond accordingly, allowing for real-time adjustments to their task execution logic.
• Maintain independent session contexts for interaction, enabling users to directly follow up on specific steps of the subagent’s task execution after the task is completed (e.g., asking “Why did you choose this data source?” or “Explain how you derived this calculation” directly to the subagent).
• Support basic session management features, such as viewing active subagent sessions, sending direct messages to specific subagents, and accessing subagent execution logs—similar to OpenClaw’s /subagents command suite (e.g., /subagents list, /subagents send, /subagents log). This feature serves as a more flexible alternative to the existing human-in-the-loop (HITL) interrupt mechanism in LangChain, as it enables direct, targeted interaction between users and subagents rather than relying on the main agent to relay all communications. It also enhances transparency and usability by allowing users to directly engage with subagents about their task execution details.

Use Case

This feature addresses a critical limitation in LangChain’s current subagent architecture, solving practical problems for users building complex multi-agent systems that require granular, user-driven control over subagent tasks. A concrete use case illustrates its value: Suppose a user builds a multi-agent system where the main agent (supervisor) delegates a data retrieval and analysis task to a dedicated subagent. The subagent is tasked with fetching data from multiple potential sources, cleaning the data, and generating a summary. During execution, the subagent encounters ambiguous data (e.g., two conflicting datasets with similar relevance) and needs user confirmation to decide which source to prioritize. Under LangChain’s current design, the subagent must return this ambiguity to the main agent, which then relays the confirmation request to the user. The user’s response is sent back to the main agent, which forwards it to the subagent—adding unnecessary latency and complexity to the workflow. With the requested feature, the subagent could directly send a confirmation request to the user: “I found two conflicting datasets (Source A and Source B) for your query. Which one should I prioritize for analysis?” The user could respond directly to the subagent (“Prioritize Source A”), which would immediately adjust its execution logic without involving the main agent. After the subagent completes the task and returns a summary to the main agent, the user might want to ask the subagent’s decision-making process: “Why did you exclude Source C from your analysis?” Instead of asking the main agent (which may not retain the subagent’s detailed execution context), the user could directly message the subagent to get a precise, context-rich explanation. For other users, this feature solves broader pain points: it reduces the main agent’s computational and communication burden by eliminating the need to relay subagent-user interactions, improves workflow efficiency by enabling real-time, direct feedback to subagents, and enhances transparency by allowing users to directly inspect and question subagent behavior. This is particularly valuable for complex multi-agent systems (e.g., research assistants, data analysis pipelines, or task orchestrators) where subagents perform specialized, granular tasks that require user input or post-execution clarification.

Proposed Solution

Based on OpenClaw’s sub-agent session design and LangChain’s existing multi-agent architecture, I propose the following implementation approach, which would be backward-compatible and integrate seamlessly with current subagent workflows:

1. Add a SubagentSession Class: Introduce a new class to manage independent session contexts for subagents, including session IDs, execution state (active/inactive/completed), message history (subagent → user and user → subagent), and execution logs. This class would mirror OpenClaw’s session management logic, where each subagent spawns in an independent session with a unique identifier (e.g., agent:<agentId>:subagent:<uuid>).
2. Implement Direct Message Routing: Extend LangChain’s subagent interface to include methods for sending direct messages to users and receiving user responses. This could involve adding a send_message() method for subagents to initiate user requests and a receive_message() method to handle user input. A lightweight message router would ensure messages are delivered to the correct subagent session, with fault-tolerance (e.g., retries for failed deliveries) similar to OpenClaw’s session mechanism.
3. Integrate Session Management APIs: Add high-level APIs to support core session management features, such as listing active subagent sessions, sending direct messages to specific subagents, retrieving subagent logs, and terminating sessions—mirroring OpenClaw’s /subagents command suite. These APIs could be exposed via LangChain’s existing tool interface or as a new SubagentManager utility.
4. Enhance Subagent State Persistence: Ensure subagents retain their execution context and message history throughout their session, even after completing their primary task. This would enable post-execution follow-up questions from users, as the subagent can reference its past steps and decisions when responding.
5. Backward Compatibility: Design the feature to be opt-in, so existing subagent implementations (where subagents report only to the main agent) continue to work without modification. Users can enable direct interaction for specific subagents by configuring a direct_interaction=True parameter when spawning subagents. This implementation would align with LangChain’s existing Deep Agents vision, which emphasizes stateful orchestration and HITL capabilities, while adding the granularity of direct subagent-user interaction. It would also leverage OpenClaw’s proven session design to ensure reliability and usability.

Alternatives Considered

I have explored several alternative workarounds to achieve similar functionality within LangChain’s current architecture, but each has significant limitations that the proposed feature would resolve:

1. Main Agent as a Relay: Using the main agent to relay all subagent-user communications (i.e., subagent sends requests to the main agent, which forwards to the user; user responses go to the main agent, which forwards to the subagent). This is the only native workaround currently available, but it adds unnecessary latency, increases the main agent’s cognitive load (requiring it to manage subagent-user message routing), and breaks the subagent’s context isolation—since the main agent must retain detailed subagent execution context to relay messages accurately. It also makes post-execution follow-up cumbersome, as the user must route all questions through the main agent, which may not have access to the subagent’s detailed logs or state.
2. HITL Interrupts for Subagents: LangChain’s existing HITL interrupt mechanism allows subagents to pause execution and request user input, but this is a limited, single-turn interaction (e.g., a subagent can ask one question, receive one response, and resume). It does not support ongoing conversation or post-execution follow-up, nor does it allow users to initiate messages to subagents (only subagents can initiate interrupts). This makes it unsuitable for scenarios requiring multiple rounds of clarification or post-task asking.
3. Custom Callback Functions: Implementing custom callbacks to capture subagent events and route messages to the user. While this can simulate basic direct interaction, it requires significant custom code, is not integrated with LangChain’s core subagent architecture, and lacks scalability (e.g., managing multiple subagent sessions, handling message routing, and persisting session state requires building custom logic from scratch). It also does not align with LangChain’s modular design principles and is difficult to maintain across version updates.
4. Using Handoff Mode: LangChain’s handoff mode allows agents to transfer control to one another, but it is designed for full agent-to-agent control transfer, not for granular subagent-user interaction. Handoffs do not support independent subagent sessions or post-execution follow-up, and they require the main agent to cede control entirely, which is not ideal for multi-subagent workflows. None of these alternatives provide the flexibility, efficiency, or usability of direct subagent-user interaction as proposed, making the feature a necessary addition to LangChain’s multi-agent toolkit.

Additional Context

To further clarify the feature’s purpose and implementation, I provide the following additional context and references:

• Reference Implementations: The core functionality being requested is modeled after OpenClaw’s sub-agent session tool, which enables spawning subagents in independent sessions, direct message interaction, and session management. OpenClaw’s documentation details how subagents can be spawned with /subagents spawn, send direct messages to users, and receive user input via commands like /subagents send and /subagents steer—this is the exact pattern we aim to replicate in LangChain.

• LangChain’s Current Limitation: LangChain’s official documentation explicitly states that subagents do not support direct user interaction, with all communications routed through the main agent. This limitation is a key pain point for users building complex multi-agent systems, as noted in LangChain’s multi-agent documentation and community discussions about subagent flexibility.

• Example Workflow with the Proposed Feature:

  1. Main agent spawns a subagent with direct_interaction=True to perform data analysis.
  2. Subagent encounters ambiguous data and sends a direct message to the user: “Please confirm: should I use Dataset X (updated 2026) or Dataset Y (updated 2025) for analysis?”
  3. User responds directly to the subagent: “Use Dataset X.”
  4. Subagent proceeds with Dataset X, completes the analysis, and sends a summary to the main agent.
  5. User follows up directly with the subagent: “Explain how you handled missing values in Dataset X.”
  6. Subagent responds directly with a detailed explanation of its missing value handling logic, using its retained session context.

• Relevance to LangChain’s Roadmap: This feature aligns with LangChain’s focus on enhancing multi-agent capabilities, particularly Deep Agents, which emphasize stateful orchestration, HITL, and subagent specialization. Adding direct subagent-user interaction would make LangChain’s multi-agent system more flexible and competitive with tools like OpenClaw, which already offer this functionality.

• Links for Reference:

  • OpenClaw Sub-Agent Session Feature: https://docs.openclaw.ai/concepts/session-tool#spawning-sub-agents
  • LangChain Subagents Current Limitations: https://docs.langchain.com/oss/python/langchain/multi-agent/subagents#key-characteristics
  • OpenClaw Sub-Agent Commands: https://openclawx.cloud/zh/tools/subagents This feature would fill a critical gap in LangChain’s subagent functionality, enabling more intuitive, efficient, and transparent multi-agent workflows for users across various use cases.