Atlas

Visual maps of AI-native systems.

Six dimensions shape every multi-agent system: orchestration, memory, routing, governance, observability, and human-in-the-loop. This atlas maps how the leading frameworks handle each, with orchestration as the lead lens.

Framework maps

Each framework carries control on a different substrate: a state graph, a conversation, a chain of handoffs, a role hierarchy, or a composable workflow. The diagram shows its signature orchestration shape. Tap a node to trace its connections, or play the flow.

LangGraph

Stateful supervisor graph

Agents are nodes in a directed state graph; a supervisor node routes to workers and loops until the goal state is reached.

The six dimensions, in detail

OrchestrationA StateGraph of nodes and edges. A supervisor node routes to worker nodes and the graph loops until it reaches END.
MemoryCheckpointers persist graph state per thread, enabling pause, resume, and time-travel debugging.
RoutingConditional edges choose the next node from the current state.
GovernanceValidation lives in nodes; interrupts gate sensitive steps before they run.
ObservabilityLangSmith tracing captures every node transition and state diff.
Human in the loopinterrupt and interrupt_before pause the graph for human review, then resume from the checkpoint.

Official documentation

Hover or tap a node to trace its connections, or play the flow.

CrewAI

Role-based crew

Agents have a role, goal, and backstory; a process runs them sequentially or hands them to a manager agent that delegates and collects.

The six dimensions, in detail

OrchestrationRole-based agents run under a Process: sequential task order, or hierarchical with a manager agent delegating to the crew.
MemoryBuilt-in short-term, long-term, and entity memory; long-term memory persists across runs in a local store.
RoutingThe manager (hierarchical) or task sequence (sequential) routes work; agents can delegate to peers.
GovernanceEach task declares expected_output and can attach guardrails that validate results.
ObservabilityVerbose logging and event listeners; integrates with tracing tools such as AgentOps.
Human in the loopSetting human_input on a task pauses execution for operator feedback.

Official documentation

Hover or tap a node to trace its connections, or play the flow.

AutoGen

Conversational group chat

Agents collaborate in a shared conversation; a manager or selector policy picks who speaks next each turn.

The six dimensions, in detail

OrchestrationAgents converse in a group chat; a manager selects the next speaker. v0.4 adds an actor-model runtime and reusable Teams (RoundRobin, Selector).
MemoryConversation history is the working memory; external memory stores are opt-in.
RoutingRoundRobinGroupChat or SelectorGroupChat chooses the next agent; handoffs are supported.
GovernanceTermination conditions and allowed-speaker rules bound the chat; code runs in sandboxes.
Observabilityv0.4 emits OpenTelemetry traces alongside message logging.
Human in the loopA UserProxyAgent can require human input or approval mid-conversation.

Official documentation

Hover or tap a node to trace its connections, or play the flow.

OpenAI Agents

Agents with handoffs

Small agents with instructions and tools pass control to one another through explicit handoffs, fronted by guardrails.

The six dimensions, in detail

OrchestrationLightweight agents with instructions and tools; a triage agent passes control through explicit handoffs.
MemorySessions automatically persist conversation history across runs.
RoutingHandoffs are modeled as tools; a triage agent routes to specialists.
GovernanceInput and output guardrails validate and can halt a run; tool schemas are typed.
ObservabilityBuilt-in tracing visualizes runs, handoffs, and tool calls.
Human in the loopTool calls can require human approval before they execute.

Official documentation

Hover or tap a node to trace its connections, or play the flow.

Claude / Anthropic

Orchestrator and workers

Composable workflow patterns plus autonomous agents: an orchestrator dynamically splits a task into worker calls, then synthesizes the result.

The six dimensions, in detail

OrchestrationComposable workflow patterns - prompt chaining, routing, parallelization, orchestrator-workers, evaluator-optimizer - plus autonomous agents for open-ended tasks.
MemoryStateless by default; context is passed explicitly, with files and external memory added when needed.
RoutingA router classifies input to a path; an orchestrator decomposes tasks to workers at run time.
GovernanceGuardrails through tool design and evaluator-optimizer loops; the Agent SDK scopes permissions and subagents.
ObservabilityTracing through the API and Agent SDK; evaluator steps score intermediate outputs.
Human in the loopPatterns favor explicit human checkpoints; the Agent SDK supports permissioned, reviewable tool use.

Official documentation

Hover or tap a node to trace its connections, or play the flow.

Gemini / Google ADK

Composable agent hierarchy

Compose LlmAgents with workflow primitives - Sequential, Parallel, and Loop agents - into multi-agent hierarchies.

The six dimensions, in detail

OrchestrationCompose agents with workflow primitives - SequentialAgent, ParallelAgent, LoopAgent - around LlmAgents to form multi-agent hierarchies.
MemorySession state plus pluggable Memory services; Vertex AI Agent Engine offers managed sessions and memory.
RoutingLLM-driven transfer between sub-agents, or deterministic order through workflow agents.
GovernanceBefore and after callbacks and plugins gate model, tool, and agent steps; Vertex adds safety controls.
ObservabilityBuilt-in evaluation and tracing that integrate with Cloud tracing.
Human in the loopHuman approval through tools and callbacks; long-running operations can await input.

Official documentation

Hover or tap a node to trace its connections, or play the flow.

Business OS pattern

Governed control plane

A supervisor pulls tasks from a work queue and dispatches them to worker agents that run business operations behind policy gates and an audit ledger.

The six dimensions, in detail

OrchestrationA supervisor pulls tasks from a work queue and dispatches them to worker agents that carry out business operations.
MemoryDurable state lives in the queue, task records, and an append-only audit ledger.
RoutingThe supervisor assigns by capability; every result flows through a policy gate.
GovernancePolicy and compliance gates validate each action and require approval for risky steps - the defining trait of the pattern.
ObservabilityAudit ledgers and telemetry make every decision traceable and replayable.
Human in the loopOperators approve, reject, or amend at explicit gates before actions commit.

Hover or tap a node to trace its connections, or play the flow.

The visual language

Every map is drawn from the same set of symbols. Together they cover all six dimensions: orchestration is the topology and the orchestrator, memory is the State node, routing is the route edges and routers, governance is the gates, human-in-the-loop is the Human node, and observability is the comparison view.

Nodes

Orchestrator coordinates the run
Agent a worker that does a task
Tool a tool or function call
Router / gate routing and governance
State memory and persistence
Human human in the loop

Connections

Flow a sequential step
Route control routed to an agent
Return control handed back
Human a human checkpoint
State I/O reads or writes state

At a glance

Every framework against every dimension, side by side. Pick a framework to jump to its map.

Framework	Orchestration	Memory	Routing	Governance	Observability	Human in the loop
LangGraph	Stateful graph + supervisor	Checkpointer threads	Conditional edges	Node validation + interrupts	LangSmith traces	Graph interrupts
CrewAI	Role crew (seq / hierarchical)	Short / long / entity	Manager delegation	Task guardrails	Event listeners	human_input task flag
AutoGen	Group chat + manager	Conversation history	RoundRobin / Selector	Termination + sandbox	OpenTelemetry	UserProxyAgent
OpenAI Agents	Agents + handoffs	Sessions	Handoff-as-tool	In / out guardrails	Built-in tracing	Tool approval
Claude / Anthropic	Orchestrator-workers	Explicit context	Router + decomposition	Evaluator + permissions	API / SDK tracing	Permissioned tools
Gemini / Google ADK	Workflow-agent hierarchy	Sessions + memory svc	Transfer / workflow order	Callbacks + plugins	Eval + Cloud trace	Approval callbacks
Business OS pattern	Queue + supervisor	Queue + audit ledger	Capability assignment	Policy gates (defining)	Audit ledger	Operator gate approval

Six dimensions

Every multi-agent system answers the same six questions. Here is each dimension and how all seven frameworks handle it, with orchestration as the lead lens.

Orchestration

How work is decomposed and coordinated across agents: supervisor graphs, sequential chains, parallel fan-out, loops, handoff networks, and role hierarchies.

LangGraphStateful graph + supervisor
CrewAIRole crew (seq / hierarchical)
AutoGenGroup chat + manager
OpenAI AgentsAgents + handoffs
Claude / AnthropicOrchestrator-workers
Gemini / Google ADKWorkflow-agent hierarchy
Business OS patternQueue + supervisor

Memory

What persists across steps and sessions: run state, checkpoints, short and long term stores, and recalled context.

LangGraphCheckpointer threads
CrewAIShort / long / entity
AutoGenConversation history
OpenAI AgentsSessions
Claude / AnthropicExplicit context
Gemini / Google ADKSessions + memory svc
Business OS patternQueue + audit ledger

Routing

How control and data reach the right agent or tool: conditional edges, handoffs, manager selection, and delegation.

LangGraphConditional edges
CrewAIManager delegation
AutoGenRoundRobin / Selector
OpenAI AgentsHandoff-as-tool
Claude / AnthropicRouter + decomposition
Gemini / Google ADKTransfer / workflow order
Business OS patternCapability assignment

Governance

The guardrails, policies, validation, and approval gates that keep agents inside their bounds.

LangGraphNode validation + interrupts
CrewAITask guardrails
AutoGenTermination + sandbox
OpenAI AgentsIn / out guardrails
Claude / AnthropicEvaluator + permissions
Gemini / Google ADKCallbacks + plugins
Business OS patternPolicy gates (defining)

Observability

The tracing, telemetry, and evaluation that make an agent run inspectable and replayable.

LangGraphLangSmith traces
CrewAIEvent listeners
AutoGenOpenTelemetry
OpenAI AgentsBuilt-in tracing
Claude / AnthropicAPI / SDK tracing
Gemini / Google ADKEval + Cloud trace
Business OS patternAudit ledger

Human in the loop

Where a person reviews, approves, edits, or interrupts the run before it continues.

LangGraphGraph interrupts
CrewAIhuman_input task flag
AutoGenUserProxyAgent
OpenAI AgentsTool approval
Claude / AnthropicPermissioned tools
Gemini / Google ADKApproval callbacks
Business OS patternOperator gate approval

How to choose a framework

Start from what you need: match your situation to a framework below. For the mental model behind the picks, choose by what carries control between agents.

Durable, resumable runs you can pause, inspect, and hand to a humanLangGraph
A team of role-based agents working a task list, fastCrewAI
Open-ended collaboration where agents talk it throughAutoGen
A few specialists that hand off, with tracing built inOpenAI Agents
Start with the simplest workflow and add agents only when neededClaude / Anthropic
Deterministic and model-driven control on Google Cloud, with A2AGemini / Google ADK
Operations that must be governed, audited, and approvedBusiness OS pattern

The mental model: what carries control

A graph over shared stateLangGraphChoose when you need durable, resumable, inspectable runs with human checkpoints.
A conversationAutoGenChoose when collaboration is open-ended and you want emergent back-and-forth.
Handoffs between specialistsOpenAI Agents, AutoGen SwarmChoose when a few agents pass control and you want minimal machinery.
A role hierarchyCrewAIChoose when the work maps to an org chart of roles and tasks.
A composable workflowClaude / Anthropic, Google ADKChoose when you mix deterministic steps with model decisions and add complexity only as needed.
A governed control planeBusiness OSChoose when operations must be audited and approved - it wraps any of the above.

Validated against each framework's official documentation, 2026. Machine readable at /api/atlas.