Multi-Agent: Context Saturation Is the Signal
Every multi-agent tutorial presents multi-agent architecture as an advanced power feature — the thing you build when you want a more capable system. This framing produces the wrong intuition and leads engineers to introduce multi-agent complexity before it’s warranted.
The correct framing: multi-agent architecture is a scaling solution for a specific, diagnosable symptom. Most agents don’t need it. The ones that do exhibit one recognisable trigger.
The trigger: context saturation
The Cortance production guide documents a consistent finding across production OpenClaw deployments: quality degrades noticeably above 15–20 active skills per agent. This is not a hard OpenClaw limit — it is a cognitive load limit. The model’s attention is divided across too many competing instruction sets to reason reliably about any single domain.
Symptoms of context saturation: the agent activates the wrong skill for a task. Responses become inconsistent across runs of the same task. Quality on complex multi-step tasks degrades while simple tasks remain fine. If you’re experiencing these symptoms and you have more than 15 active skills, context saturation is the likely cause.
The solution: specialisation. One agent per domain, each with 5–10 focused skills. The Lobster orchestrator routes messages to the correct specialist.
This is the only correct trigger for multi-agent. Not “I want more capability.” Not “I read that multi-agent is advanced.” Context saturation — specific, measurable, resolvable through specialisation.
The maxSpawnDepth constraint
OpenClaw’s Lobster workflow engine defaults maxSpawnDepth to 1. The maximum is 2. This means:
An orchestrator can spawn worker agents (depth 1) ✓
Worker agents at depth 1 cannot spawn further agents in a depth-1 config ✓
At depth 2: orchestrator spawns managers, managers spawn workers — technically possible ✗ (unreliable in production)
Supervisor hierarchies deeper than two levels fail consistently in production. Context at depth 3 is too diluted — the orchestrator’s framing of the task loses precision as it passes through layers of interpretation. The Lobster documentation notes this explicitly.
Practical rule: design for depth 1. If your workflow seems to require depth 3, the problem is almost always a domain decomposition issue — you’re trying to solve a complex problem with hierarchy when you should solve it with better skill design on a single specialist.
Three patterns that work within depth 1
Domain specialist fleet — orchestrator routes by intent. Code tasks go to the code agent (GitHub, CLI, file operations). Communication tasks go to the communication agent (email, calendar, messaging). Data tasks go to the data agent (database, API, analysis). The orchestrator does minimal work itself — its primary job is routing. Each specialist has 5–8 focused skills.
Sequential pipeline — agent A processes input and hands off to agent B, which hands off to agent C. Each agent handles one transformation step. The output of each step is the input of the next. Use for: data processing pipelines where each step requires distinct expertise and the steps are sequential by nature.
Parallel gather — orchestrator spawns multiple agents simultaneously to gather data from different sources. Waits for all results. Synthesises. Faster than sequential for data-gathering tasks where sources are independent. Cost: spawning three agents simultaneously means three concurrent LLM calls — approximately 3x the cost of a single-agent call.
The pattern that breaks consistently: supervisor hierarchies — orchestrator → manager → worker. The additional layer of interpretation degrades the original task framing beyond useful precision. Don’t build this.
Three things to carry forward: 1. Multi-agent is a solution to context saturation at 15–20 skills — not a general capability upgrade. 2. maxSpawnDepth defaults to 1. Maximum 2. Never design for depth 3. 3. Three patterns work: domain specialist fleet, sequential pipeline, parallel gather. Supervisor hierarchies don’t.
Issue 16 drops Thursday — the complete Lobster YAML for a domain specialist fleet with three agents under one orchestrator. Annotated failure modes. The debugging approach for multi-agent systems where a silent worker failure produces a plausible-but-wrong result.