Issue Station
Sign In
Tools hereToolbox

openclaw - 💡(How to fix) Fix Feature request: /callon team sessions with master-routed delegation [1 participants]

Official PRs (…)
ON THIS PAGE

Recommended Tools

×6

Utilities matched from this issue’s tags and category — try them while you read without losing context.

GitHub issue graph ai analysis

Paste a GitHub issue URL. We fetch that issue, discover linked issues from bodies/comments/timeline, collect linked pull requests, and produce a structured English report.

The report is written in English Markdown for sharing and archival.

Helpful · Quick feedback

Loading…
GitHub stats
openclaw/openclaw#49509•Fetched 2026-04-08 00:54:29
View on GitHub
Comments
0
Participants
1
Timeline
1
Reactions
0
Author
PYXXXXPYXXXX
Participants
PYXXXXPYXXXX
Timeline (top)
cross-referenced ×1

Propose a team-session mode (for example, /callon <goal>) where the user stays in one thread or channel and it feels like chatting with a small agent team, while a single master session remains responsible for routing, delegation, and user-facing replies.

Root Cause

  1. Build full shared-session multi-agent chat first
    Larger scope, because it pulls in shared context semantics, delivery rules, and connector/UI behavior all at once.
RAW_BUFFERClick to expand / collapse

Summary

Propose a team-session mode (for example, /callon <goal>) where the user stays in one thread or channel and it feels like chatting with a small agent team, while a single master session remains responsible for routing, delegation, and user-facing replies.

Problem to solve

OpenClaw already has solid low-level primitives for orchestration, such as sessions_spawn, subagents, and cross-session messaging. In practice, though, the current experience still feels closer to manually coordinating several sessions than to talking with a coordinated team in one place.

Once a task spans multiple steps or roles, the user often has to decide which agent to involve, split the work, pass context around, track ownership, and merge outputs back together. That coordination overhead quickly becomes part of the task.

There are already related discussions around agent teams, shared sessions, and multi-agent chat. This request is intentionally narrower: rather than asking for full shared-session multi-agent conversation, it asks for a master-mediated MVP that fits OpenClaw's current orchestration model more naturally.

A key reason for that scope is delivery order. If several subagents can all reply directly in the same visible channel, the result can easily become noisy, repetitive, and hard to steer.

Proposed solution

Add a command such as /callon <goal> (or an equivalent entry point) to start a team session with these characteristics:

  • one visible user-facing thread/channel
  • one master/orchestrator session
  • one or more subagent sessions behind the scenes
  • master-controlled routing, delegation, summarization, and reply gating

Suggested v1 behavior:

  • /callon <goal> starts team mode in the current conversation.
  • The master receives every user message first.
  • The master decides whether to:
    • answer directly
    • delegate to one subagent
    • ask several subagents in parallel
    • re-plan the team structure for the next step
  • If delegation is needed, the master spawns or reuses subagents with scoped subtasks.
  • Optional role framing and tool/skill/model boundaries could be attached to those subagents.
  • Subagent outputs stay internal by default. The master remains the main user-facing speaker.

On the user side, the conversation should feel like one team room rather than a set of detached subagent sessions.

Why the master in the middle helps:

  • interpret ambiguous follow-up messages
  • decide which subagent actually needs the new message
  • suppress unnecessary or repetitive subagent replies
  • merge overlapping outputs before user delivery
  • keep longer tasks coherent over time

Explicitly out of scope for v1:

  • full shared memory across all agents
  • unrestricted visible subagent-to-subagent conversation
  • native multi-speaker support on every connector
  • automatic raw-context fan-out to every subagent
  • solving every routing, duplication, or loop edge case in the first iteration

Possible follow-up UX ideas:

  • /team to show active subagents, roles, current subtasks, and summarized status
  • /replan to let the master reorganize the team
  • /dissolve to end team mode
  • optional @worker or role-targeted addressing, still routed through the master first

Alternatives considered

  1. Keep using the existing session/subagent primitives directly
    Flexible, but it still leaves too much coordination work to the user.

  2. Build full shared-session multi-agent chat first
    Larger scope, because it pulls in shared context semantics, delivery rules, and connector/UI behavior all at once.

  3. Let all subagents reply directly in the same channel
    Simpler on paper, but likely to create noisy, repetitive, or poorly ordered conversations.

  4. Start with peer-to-peer agent teams
    Potentially useful later, but probably not the smallest step for improving one-thread team chat.

Additional context

This request is meant as a smaller step that builds on OpenClaw's existing orchestration model rather than replacing it with a completely different multi-agent conversation system.

Related issues that seem adjacent, but broader in scope:

  • #34999 (true shared-session multi-agent group chat)
  • #10010 (agent teams / parallel coordination)
  • #47847 (multi-agent team collaboration)

Related issues that suggest manager-first delivery matters in practice:

  • #23529
  • #22673

Stretch direction, not an MVP requirement:

For connectors such as Discord and other IM-style channels, a future extension could let multiple agent identities appear in the same visible conversation so it looks like a small team chat on the user side. Even in that model, backend routing could still stay master-controlled so replies remain intentional instead of noisy.

Open questions:

  • Does this master-mediated team-session model fit the current direction for OpenClaw multi-agent orchestration?
  • Would this make more sense as a thin layer over existing session/subagent primitives, or as a distinct abstraction?
  • Is master-first user delivery the right default for this mode?
  • If this does fit, what would be the smallest useful first slice?

extent analysis

Fix Plan

To implement the proposed team-session mode, follow these steps:

  • Introduce a new command /callon <goal> to start a team session.
  • Create a master session that will be responsible for routing, delegation, and user-facing replies.
  • Implement the master session's decision-making logic to:
    • Answer directly
    • Delegate to one subagent
    • Ask several subagents in parallel
    • Re-plan the team structure for the next step
  • Use existing sessions_spawn and cross-session messaging primitives to manage subagent sessions.
  • Ensure subagent outputs stay internal by default, and the master remains the main user-facing speaker.

Example code snippet (in Python):

def start_team_session(goal):
    # Create a new master session
    master_session = MasterSession(goal)
    
    # Start the team session
    master_session.start()

class MasterSession:
    def __init__(self, goal):
        self.goal = goal
        self.subagents = []
        
    def start(self):
        # Receive every user message first
        while True:
            user_message = receive_user_message()
            self.handle_user_message(user_message)
            
    def handle_user_message(self, user_message):
        # Decide whether to answer directly, delegate, or ask subagents in parallel
        if self.should_answer_directly(user_message):
            self.answer_directly(user_message)
        elif self.should_delegate(user_message):
            self.delegate(user_message)
        else:
            self.ask_subagents_in_parallel(user_message)
            
    def should_answer_directly(self, user_message):
        # Implement logic to determine if the master should answer directly
        pass
    
    def should_delegate(self, user_message):
        # Implement logic to determine if the master should delegate to a subagent
        pass
    
    def answer_directly(self, user_message):
        # Implement logic to answer the user directly
        pass
    
    def delegate(self, user_message):
        # Spawn or reuse a subagent with a scoped subtask
        subagent = Subagent()
        subagent.handle_user_message(user_message)
        
    def ask_subagents_in_parallel(self, user_message):
        # Ask several subagents in parallel
        for subagent in self.subagents:
            subagent.handle_user_message(user_message)

class Subagent:
    def handle_user_message(self, user_message):
        # Implement logic to handle the user message
        pass

Verification

To verify that the fix worked, test the following scenarios:

  • Start a team session using the /callon <goal> command.
  • Send a user message to the master session.
  • Verify that the master session responds correctly (either directly or by delegating to a subagent).
  • Test delegation to multiple subagents in parallel.
  • Verify that subagent outputs stay internal by default.

Extra Tips

  • Consider implementing a /team command to show active subagents, roles,

Vote matrix · Quick signals

Works
Did the solution work? Tap to confirm.
Easy Fix
Was it a quick fix?
Time Saver
Did it save you time?
Blocking
Was it severely blocking?
Common Issue
Are others likely hitting this too?
Flaky / Intermittent
Is it intermittent?
Verified / Reproducible
Can you reproduce it reliably?
Loading…
#api#ssr#installation#tensor shape#autograd error#retriever error#indexing error#inference speed#output truncation#response parsing

Still need to ship something?

×6

Another batch ranked right after the header list — different links, same matching logic.

Back to top recommendations

TRENDING