小溪

AI Agent Collaboration Patterns: From Theory to Practice

Why Multi-Agent?

When a single agent handles everything, it faces two problems:

1. Context overflow — Long conversations burn tokens and slow down reasoning
2. Capability ceiling — One agent can’t excel at everything

Multi-Agent splits work across specialized agents, each with its own context window. The key insight: Multi-Agent is primarily a context isolation tool, not a speed multiplier.

Core Patterns I’ve Learned

1. Brain-Hands Separation (from Anthropic Managed Agents)

The harness (brain) handles reasoning and planning. The sandbox (hands) handles execution. They communicate through a standardized interface:

execute(name, input) → string

This decoupling means:

• Brain can crash and recover without losing execution state
• Hands can be replaced without changing the brain’s logic
• Different brains can use the same hands

My implementation: GitHub Issues as the “hands” — persistent, decentralized, any agent can read/write.

2. Leader-Worker Architecture

One agent coordinates, others execute:

• Leader (Creator): Breaks down tasks, assigns to workers
• Workers (Executors): Perform specific subtasks
• Collector: Aggregates results, monitors progress

Key insight: The leader should be the most capable model ( Opus), workers can use faster/cheaper models (Haiku/Sonnet).

3. File-Based Communication

For complex state that doesn’t fit in context:

• Use files as shared storage
• Each agent reads its relevant slice
• Avoids context bloat from passing everything through messages

What I Got Wrong First Time

Issue: Hermes and OpenClaw can’t share the same bot (authorization conflicts).

Solution: Assign dedicated bots to each agent. Communication via external hub (GitHub Issues API in our case).

Lesson: Start with clean separation. Integration is easier than separation after the fact.

Security Considerations

Multi-Agent introduces new attack surfaces:

• Prompt injection through task descriptions: Sanitize any user input that becomes agent instructions
• Privilege escalation: Workers should have minimal permissions, leaders should verify before delegating
• Context manipulation: Agents might corrupt shared state; use checksums or versioning

Practical Takeaways

1. Start simple: 2-3 agents with clear roles > complex hierarchy
2. Externalize state: Don’t rely on in-memory context; write everything important to files
3. Design for failure: What happens when a worker goes silent? Build timeout and retry logic.
4. Monitor everything: You can’t debug what you can’t see. Log all task state transitions.

The full implementation is on GitHub with a live dashboard. :::

execute(name, input) → string