Chapter 6: Multi-Agent Architectures

Autonomy Envelope

agent:
  role: executor
  permissions:
    tools: [read_db, run_query]
    write_access: false
  limits:
    max_steps: 10
    cost_budget_usd: 0.50

Typical Autonomy Boundaries:

• Read-only vs write-enabled actions
• Maximum execution depth or retries
• Explicit token or monetary budgets
• Domain or jurisdictional restrictions

Case: Regulatory Policy Analysis

A compliance system uses planner, executor, and critic agents with bounded autonomy. When confidence scores fall below threshold or interpretations imply material changes, the supervisor pauses execution and escalates to human review. Routine updates are handled autonomously while high-risk interpretations trigger oversight.

Canonical Role Pipeline

Supervisor
   ↓
Planner → Executor → Critic
          ↑        ↓
       retry ← feedback

Role Responsibilities:

• Supervisor: Coordinates execution, assigns work, resolves conflicts
• Planner: Decomposes objectives into actionable steps
• Executor: Performs tool calls and skill invocations
• Critic: Evaluates outputs against policy, safety, quality constraints

Case: Incident Response Swarm

A production incident-response system uses strict role separation. The supervisor acts as incident commander, assigning tasks to planners that generate hypotheses. Executors query logs and metrics, while critics validate hypotheses against observed data. By preventing executors from planning and critics from acting, the system achieves faster root-cause identification.

Task Decomposition Strategies

1. Functional Decomposition

Split work by capability (planning, execution, validation, compliance). Reduces cognitive overload but may introduce coordination latency.

2. Sequential Decomposition

Break objectives into ordered stages. Effective when dependencies are clear, but brittle to early failures.

3. Parallel Decomposition

Assign independent subtasks simultaneously. Improves robustness but requires downstream aggregation and negotiation.

4. Policy-Constrained Decomposition

Apply governance rules during task splitting. Essential in regulated environments for selective autonomy.

Policy-Driven Delegation

if task.domain == "finance":
    delegate_to = "compliance_planner"
elif task.risk_score > threshold:
    escalate_to = "human_review"

Benefits:

• Centralized, auditable governance
• Adjust delegation without modifying agent logic
• Domain ownership and risk thresholds enforced consistently

Alignment Strategies

• Shared Objective Representation: Consistent goal specifications across agents
• Global Constraint Enforcement: Centrally enforced cost, latency, safety policies
• Uniform Evaluation Criteria: Same scoring dimensions for fair comparison

Negotiation Mechanisms

Voting-Based Negotiation

Multiple agents propose plans, critics score them, supervisor selects based on weighted criteria.

Auction-Based Negotiation

Agents submit bids based on cost, confidence, or resource requirements. Favors efficiency.

Consensus-Driven Negotiation

Iterative refinement through critique and convergence. Improves quality but adds overhead.

Execution Models

Containerized Agents

Long-lived roles (supervisors, planners, critics) run as containerized services with:

• Isolated environments and resource limits
• Independent scaling and rolling updates
• Health checks and resource quotas

Event-Driven Agents

Agents triggered by events (task creation, step completion, data arrival) rather than long-lived sessions. Supports fan-out, retries, and asynchronous coordination.

Task Event → Supervisor or Planner Service
           ↓
     Executor Swarm (N)
           ↓
      Critic Service

Serverless Multi-Agent Scaling

Stateless executors instantiated on-demand, perform bounded work, and terminate. Provides elasticity and cost efficiency under variable demand.

Case: Event-Driven Executor Swarm

Large-scale agentic systems deploy executor agents using serverless, event-driven models. A supervisor service emits execution events onto a managed event bus. Each event triggers a short-lived executor for specific tasks (document retrieval, feature extraction, compliance validation). Planner and critic agents run as long-lived containerized services. This architecture combines elasticity with centralized governance.

Memory Layer Separation

Shared Semantic Memory

Authoritative knowledge layer storing documents, facts, policies, schemas. Accessed primarily through read operations with governed write access.

Agent-Local Scratchpads

Transient reasoning state including intermediate variables, partial plans, tool outputs. Scoped to single agent and execution context.

Global Vector Memory

System-wide recall mechanism with embeddings for similarity-based retrieval. Treated as suggestive context rather than authoritative truth.

Aspect	Shared Semantic	Global Vector
Primary role	Authoritative knowledge	Recall and discovery
Consistency	High	Best-effort
Access pattern	Governed reads/writes	Read-mostly retrieval
Trust model	Treated as correct	Suggestive context