openclaw - 💡(How to fix) Fix Design input needed: token-cost scaling in conversational multi-agent coordination [1 comments, 1 participants]

Summary

Multi-agent conversational coordination — where every agent reads the full prior conversation each turn — has token cost that grows roughly quadratically with agents × rounds. We observed this empirically running 5 agents over 3 rounds on a single shared task and ended up burning a significant chunk of $150 on a scenario that didn't, on the surface, justify it.

Filing this to surface the architectural pattern and invite community design input. We are explicitly not proposing a fix — the right trade-off isn't obvious to us, and naive solutions risk eroding the property that makes conversational coordination valuable in the first place.

What we observed

• Setup: 5 agents (parent personas), 3 rounds, GPT-4o, cross-agent messaging via sessions_send / sessions_history. Scenario: coordinate emergency school pickup of 7 children in 45 minutes.
• Run shape: ~80–100 LLM calls. Each agent's call included the full prior conversation each turn, so per-call input tokens grew steadily through the run.
• Outcome quality: the run produced an honest, constraint-valid plan (5/7 assigned, 2 explicitly flagged as unresolved). Quality was good. The cost of getting there was the concern.
• Cost shape: with N agents and M rounds, total tokens scale roughly as N × M × (N × M) because each later turn re-ingests every earlier turn. At our (5, 3) it's expensive but tolerable; at (10, 5) it's an order of magnitude worse; at (20, 10) it's prohibitive.

The trade-off that makes this hard

The broadcast pattern is the mechanism that produces the qualitative wins of conversational coordination — emergent-information moments where one agent's reveal unlocks another agent's reasoning. Concretely, in our run: Diana mentioned that one child (Zuri) had met another helper (Emi) at a block party, which changed Raj's reasoning about pickup pairings even though Raj and Diana had no obvious topical overlap. Naive cost reduction (e.g. "only send to topically-relevant agents") would silently kill that property and erode the very thing that makes conversational mode interesting.

So this isn't a "broadcast is wasteful, remove it" issue. It's a "how do we keep the property at scale" issue.

Open questions for the community

1. Has anyone landed on a coordination pattern that preserves emergent information at lower cost? Specifically: a way for cross-domain reveals to still reach non-obvious recipients without every agent ingesting the full transcript every turn.
2. Is per-agent context filtering (saliency / relevance scoring) a viable middle ground? If so, what scoring approach has worked, and what's the failure mode when saliency drifts?
3. Are there published patterns (topic routing, role-based subscriptions, summary tiers, attention sinks, hierarchical agents, etc.) with empirical data behind them at multi-agent scales? Pointers welcome.
4. Where should this trade-off be exposed in OpenClaw's surface? A coordination-mode knob, a config primitive, or is this a per-scenario harness concern that doesn't belong in the framework at all?
5. How does this interact with OpenClaw's existing star-topology MAS (sessions_spawn + targeted sessions_send)? Should "conversational coordination" be understood as a separate primitive that needs its own scaling story, or as a degenerate case of MAS that shouldn't be encouraged at scale?

What this issue is not

• Not a bug report — broadcast in small scenarios is deliberate and valuable.
• Not a feature proposal — we're not asking for a specific implementation.
• Not a performance-tuning ask — model choice and prompt size are separately tunable; the cost shape we're describing is structural, not configurational.

Just trying to make sure this is on the radar before users hit it on bigger scenarios. Open to converting this to a Discussion if that's the better venue.

Repro

Scenario, agent contexts, and runner scripts can be shared on request. Anyone wanting to reproduce just needs an OpenClaw install with 5 agents registered, a shared task brief, and a 3-round orchestrator that sends each agent the full conversation each turn — the cost shape will be visible in the first 2-3 rounds.