Building Multi-Agent, Tool-Using Agentic Systems

Overview

Comprehensive architecture patterns for multi-agent systems where AI agents coordinate to accomplish complex tasks using tools. Language-agnostic and applicable across TypeScript, Python, Go, Rust, and other environments.

Discovery Questions (Required)

Before architecting any system, ask these six mandatory questions:

1. Starting Point - Greenfield, adding to existing system, or fixing current implementation?
2. Primary Use Case - Parallel work, sequential pipeline, recursive delegation, peer collaboration, work queues, or other?
3. Scale Expectations - Small (2-5 agents), medium (10-50), or large (100+)?
4. State Requirements - Stateless runs, session-based, or persistent across crashes?
5. Tool Coordination - Independent agents, shared read-only resources, write coordination, or rate-limited APIs?
6. Existing Constraints - Language, framework, performance needs, compliance requirements?

Foundational Architecture

Four-Layer Stack

Every agent follows the four-layer architecture for testability, safety, and modularity:

| Layer | Name | Responsibility | |-------|------|----------------| | 1 | Reasoning (LLM) | Plans, critiques, decides which tools to call | | 2 | Orchestration | Validates, routes, enforces policy, spawns sub-agents | | 3 | Tool Bus | Schema validation, tool execution coordination | | 4 | Deterministic Adapters | File I/O, APIs, shell commands, database access |

Critical Rule: Everything below Layer 1 must be deterministic. No LLM calls in tools.

See references/four-layer-architecture.md for detailed implementation with code examples.

Foundational Patterns

| Pattern | Purpose | |---------|---------| | Event-Sourcing | All state changes as events for audit trails and replay | | Hierarchical IDs | Encode delegation hierarchy (e.g., session.1.2) for cost aggregation | | Agent State Machines | Explicit states (idle → thinking → tool_execution → stopped) with invalid transition errors | | Communication | EventEmitter for state changes, promises for result collection |

Seven Coordination Patterns

Choose based on discovery question answers:

| Pattern | Use Case | Trade-offs | |---------|----------|------------| | Fan-Out/Fan-In | Parallel independent work | Fast but costly; watch for orphans | | Sequential Pipeline | Multi-stage transformations | Bottleneck at slowest stage | | Recursive Delegation | Hierarchical task breakdown | Must add depth limits | | Work-Stealing Queue | 1000+ tasks with load balancing | No built-in priority | | Map-Reduce | Cost optimization | Cheap map ($0.01), smart reduce ($0.15) | | Peer Collaboration | LLM council for bias reduction | Expensive (3N+1 calls), slow | | MAKER | Zero-error tasks (100K+ steps) | 5× cost but ~0% error rate |

See references/coordination-patterns.md for detailed implementations.

Pattern Selection Guide

| Requirement | Recommended Pattern | |-------------|---------------------| | Parallel independent tasks | Fan-Out/Fan-In | | Each stage depends on previous | Sequential Pipeline | | Complex task decomposition | Recursive Delegation | | Large batch processing | Work-Stealing Queue | | Cost-sensitive analysis | Map-Reduce | | Need diverse perspectives | Peer Collaboration | | Zero error tolerance | MAKER |

MAKER Pattern (Zero Errors)

For tasks requiring 100K+ steps with zero error tolerance (medical, financial, legal domains):

1. Extreme Decomposition - Recursive breakdown until each subtask <100 steps
2. Microagents - Single tool, focused expertise, cheap models
3. Multi-Agent Voting - N parallel attempts per subtask, majority consensus
4. Error Correction - Deterministic validation + retry with failure context

Cost comparison: Same cost as traditional approach, zero errors vs. 10+ errors.

See references/maker-pattern.md for full implementation with medical diagnosis example.

Tool Coordination

| Mechanism | Purpose | |-----------|---------| | Permission Inheritance | Children inherit subset of parent permissions (cannot escalate) | | Resource Locking | Acquire/release patterns for shared resources | | Rate Limiting | Token bucket algorithm across all agents | | Result Caching | Cache read-only, idempotent, expensive operations |

Sub-Agent as Tool Pattern: Wrap specialized agents as tools the parent can call, providing composable abstractions and natural lifecycle management.

See references/tool-coordination.md for implementations.

Critical Lifecycle: Cascading Stop

"Always stop children before stopping self." This prevents orphaned agents.

1. Get all child agents
2. Stop all children in parallel
3. Stop self
4. Cancel ongoing work
5. Flush events

If pause/resume unavailable, implement manual checkpointing: save agent state (messages, context, tool results), then restore later.

Production Hardening

| Concern | Solution | |---------|----------| | Orphan Detection | Heartbeat monitoring every 30 seconds | | Cost Tracking | Hierarchical aggregation across agent tree | | Session Persistence | Project-level task store for cross-session work | | Checkpointing | Save after 10+ tools, $1.00 cost, or 5 minutes elapsed | | Self-Modification Safety | Blast radius assessment, branch isolation, test-first |

See references/production-hardening.md for detailed implementations.

Real-World Example: Code Review System

A pull request orchestrator using Fan-Out/Fan-In:

1. Spawns four specialist reviewers in parallel (security, performance, style, tests)
2. Security and tests use smart models (Sonnet); style and performance use fast models (Haiku)
3. Each reviewer has 2-minute timeout
4. Results aggregate regardless of partial failures
5. Costs track per reviewer
6. All agents stop cleanly via cascading stop after completion

Execution Checklist

When guiding implementation of multi-agent systems:

1. Ask discovery questions - Understand requirements before architecting
2. Assess error tolerance - Zero errors → MAKER; some acceptable → simpler patterns
3. Establish four-layer architecture - Reasoning, orchestration, tool bus, adapters
4. Design schema-first tools - Typed contracts before implementation
5. Define deterministic boundary - No LLM in Layers 3-4
6. Choose orchestration model - YOLO, Safety-First, or Hybrid
7. Select coordination pattern - Fan-out, pipeline, delegation, queue, map-reduce, peer, or MAKER
8. Design tool coordination - Permission inheritance, locking, rate limiting
9. Implement cascading cleanup - Always stop children before parent
10. Add monitoring and cost tracking - Hierarchical aggregation across agent tree
11. Consider self-modification safety - If agents can modify code, add safety protocol

Common Pitfalls

| Pitfall | Impact | |---------|--------| | Missing four-layer architecture | Untestable, unsafe, hard to debug | | LLM calls in tools (Layer 3-4) | Non-deterministic, can't unit test | | No schema-first tool design | Sub-agents can't discover tools | | Missing cascading stop | Orphaned agents consuming resources | | No permission inheritance | Sub-agents can escalate privileges | | No timeouts | Indefinite hangs waiting for sub-agents | | Unbounded concurrency | Resource exhaustion from too many agents | | Ignoring cost tracking | Budget surprises | | No partial-failure handling | One failure cascades to all agents | | Unpersisted state | Unrecoverable workflows on crash | | Uncoordinated tool access | Race conditions on shared resources | | Wrong model selection | Cost inefficiency (Sonnet for simple tasks) | | Self-modification without safety | Sub-agents break themselves | | No heartbeat monitoring | Can't detect orphans after parent crash |

Reference Files

Detailed implementations with code examples:

| File | Contents | |------|----------| | references/four-layer-architecture.md | Four-layer stack, deterministic boundary, schema-first tools | | references/coordination-patterns.md | Seven coordination patterns with code | | references/maker-pattern.md | MAKER implementation, voting, medical diagnosis example | | references/tool-coordination.md | Permission inheritance, locking, rate limiting, caching | | references/production-hardening.md | Cascading stop, orphan detection, cost tracking, checkpointing |