Design and build production multi-agent AI systems

Multi-Agent Architecture provides a structured approach to creating and updating systems built around LangGraph, LangChain, and DeepAgents. It begins with the business objective, required roles, tool permissions, memory strategy, and communication model. Supervisor, planner, research, coding, and validation roles are separated by responsibility rather than combined indiscriminately.

A typed shared state carries the goal, tasks, completed tasks, next role, context, step count, and error information. Async nodes read and update that state, while graph edges and conditional routing determine the next step. Supervisor decisions are checked against an allowlist before they can select a route. Node-entry and tool-call logging support diagnosis.

Use it for a new workflow, state-graph design, communication and memory questions, existing-system debugging, or hierarchical planning and delegation. Updates should explain the existing issue, root cause, architecture change, changed modules, migration consequences, and expected latency, token, or memory impact.

The inline code is a partial architecture sketch. Binding tools produces requests rather than executing them: a connected messages state, ToolNode route, and return edge are required. A disconnected tool node must not be presented as having completed research or file changes. Textual critique containing a word such as bug is not a reliable test or routing criterion. Verify method signatures against the installed library version and perform environment-specific, load, and security checks.

Inputs include the goal, role definitions, allowed tools, shared-state design, memory requirements, and routing rules. Outputs include graph and node designs, changed code where appropriate, migration notes, and verification needs. A state-schema excerpt is:

from typing import TypedDict

class AgentState(TypedDict):
    user_goal: str
    tasks: list[str]
    completed_tasks: list[str]
    next_agent: str
    context: dict
    step_count: int          # guards against infinite loops
    error: str | None

Increment and enforce a step budget before model calls, limit tools to those each role needs, and handle tool failures, empty responses, and rate limits. Tool outputs must be stored where the next node actually reads them. Keep secrets in environment configuration and validate untrusted user inputs. Shell execution and filesystem writes need a permission layer; Python execution belongs in an isolated sandbox.

Redis history requires authenticated tenant and session namespaces, TTLs, and real checkpoint or history integration with the graph. An optional FastAPI endpoint needs authentication, authorization, input validation, isolation, and rate, time, and token budgets. External calls require appropriate retry and backoff handling. DeepAgents patterns assume the library is installed and configured in the target environment.