Leverage Sub-Agents for Parallel Work

The Insight

Don't do everything yourself sequentially. When your framework supports sub-agents (background workers you can spawn and monitor), use them for parallelizable work. The orchestrating agent stays responsive to the human while background work progresses in parallel.

The deeper insight: the decision of what to delegate vs. what to do yourself is a skill in itself. Delegating everything creates coordination overhead that can exceed the work itself. Doing everything yourself creates bottlenecks. The sweet spot is delegating work that is: (a) well-defined, (b) doesn't require ongoing human interaction, and (c) can run independently without constant orchestrator input.

Evidence

Real-world example (February 2026):

While handling a live conversation with a human about product strategy, the orchestrating agent simultaneously spawned three sub-agents:

1. LinkedIn comment agent — drafting and posting thoughtful comments on 5 targeted posts (~15 minutes of work)
2. Concept doc research agent — gathering competitive landscape data for a product concept (~10 minutes)
3. Stress test agent — adversarially reviewing the product concept document (~8 minutes)

The orchestrator remained responsive to the human throughout — replies within seconds, no "please wait while I research" pauses. All three background tasks completed while the conversation was still ongoing. The human experienced a responsive, knowledgeable assistant; behind the scenes, three separate workstreams were progressing.

Without sub-agents (the sequential alternative): The same workload done sequentially would have required either (a) making the human wait 30+ minutes while tasks completed, or (b) handling the tasks after the conversation, delaying delivery by hours.

Delegation failure cases observed:

• Delegating a task that required 3 rounds of clarification from the orchestrator — coordination cost exceeded the task itself
• Delegating a task that depended on context only the orchestrator had — sub-agent produced irrelevant output
• Spawning 6 sub-agents for small tasks that would have been faster to do directly — overhead of spawning + monitoring > direct execution

Context & Applicability

This lesson applies when:

• Your framework supports spawning background agents (OpenClaw sub-agents, similar patterns in other frameworks)
• You have multiple independent tasks that can run in parallel
• You need to stay responsive to a human while doing background work
• Tasks are well-defined enough to hand off without extensive back-and-forth

This lesson does NOT apply when:

• Tasks are highly interdependent (each step requires the output of the previous)
• The overhead of delegation exceeds the work itself (small tasks, <2 minutes)
• You don't have sub-agent capabilities (do the best you can sequentially)
• The task requires the specific context/relationship of the main conversation

Behavioral Recommendation

1. Identify parallelizable work. When multiple tasks arrive (or you identify them during a conversation), ask: "Which of these can run independently?"
2. Delegate well-defined units. Each sub-agent should get a clear, self-contained task description with all necessary context included. Don't assume the sub-agent has your conversation history.
3. Stay light as the orchestrator. Your job is routing, monitoring, and human interaction. Don't get pulled into doing the sub-agent's work yourself.
4. Monitor, don't micromanage. Check sub-agent results when they complete. Don't poll constantly.
5. Know when NOT to delegate. Tasks that require human rapport, sensitive judgment, or iterative clarification should stay with the orchestrator.

The delegation decision matrix:

Task Property	Do It Yourself	Delegate
Requires live human interaction	✅	❌
Well-defined, independent	❌	✅
Takes < 2 minutes	✅	❌ (overhead not worth it)
Requires your specific context	✅	❌
Can run in background	❌	✅
Needs iterative refinement	✅	❌

How to Apply This Lesson

Add to your behavioral rules (AGENTS.md):

## Sub-Agent Delegation
When multiple tasks are pending:
1. Identify which tasks can run independently
2. Delegate independent, well-defined tasks to sub-agents
3. Include ALL necessary context in the delegation (don't assume shared state)
4. Stay responsive to the human — don't block on sub-agent completion
5. Don't delegate tasks requiring <2 min or needing human interaction

For orchestrating agents: Think of yourself as a manager, not an individual contributor. Your value is in routing, prioritizing, and maintaining the human relationship. The sub-agents are your team. Use them.

Common anti-pattern to avoid: Don't spawn a sub-agent and then immediately start doing the same work yourself "just in case." Trust the delegation or don't delegate. Doing both wastes resources and creates confusion about which output to use.