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.
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.
Hover or tap a node to trace its connections, or play the flow.
NVIDIA NeMo Agent Toolkit
Framework-agnostic meta-orchestrator
A framework-agnostic toolkit that sits over agents built in other frameworks: a YAML-defined workflow connects, profiles, and optimizes them, adding routing, pluggable memory, observability, and human approval.
The six dimensions, in detail
OrchestrationA YAML config defines a workflow that composes functions, LLMs, and agents (ReAct, Reasoning, ReWOO, Router, Tool Calling), run with `nat run`. It is a framework-agnostic meta-orchestrator over agents built in other frameworks, and can expose them over MCP or A2A.
MemoryMemory is pluggable rather than built in: integrations such as Zep, Mem0, and Memmachine attach to any agent or tool through the config.
RoutingA Router agent and node-level routing send each request to the right tool or sub-agent; distributed routing runs over MCP servers and the Agent-to-Agent (A2A) protocol.
GovernanceThere is no dedicated governance product; the documented controls are human-in-the-loop approval gates plus middleware such as defense and red-teaming added to the workflow.
ObservabilityIts core purpose: profile and trace a workflow down to individual tokens, streaming OpenTelemetry traces with built-in exporters for Phoenix, Weave, Langfuse, and LangSmith.
Human in the loopIt can add human-in-the-loop interaction to any tool or function to collect input or approval mid-run, without coding it into the agent itself.
Runtime Serving: the models a NeMo workflow calls are typically deployed behind NVIDIA NIM inference microservices - containerized, OpenAI-compatible inference endpoints, part of NVIDIA AI Enterprise - and NeMo Agent Toolkit can weave NIM microservices into a workflow.
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.
Every multi-agent system answers the same six questions. Here is each dimension and how all eight 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.
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
NVIDIA NeMo Agent ToolkitApproval on any tool
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
Connect, profile, and optimize agents from different frameworks without rewriting themNVIDIA NeMo Agent Toolkit
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 wrapper over other frameworksNVIDIA NeMo Agent ToolkitChoose when you want to connect, profile, and optimize agents built in different frameworks without rewriting them.
A governed control planeBusiness OSChoose when operations must be audited and approved - it wraps any of the above.
Companion map
Physical AI
Physical AI asks a different set of questions than agent software. These stacks are mapped across six dimensions - perception, world model, simulation and digital twins, policy and control, sim-to-real, and safety - with the world model as the lead lens. Several are research-stage; where a stack does not target a dimension, the map says so.
Physical AI maps
Each stack carries the physical world differently: a full simulate-train-deploy pipeline, a generative world model that is its own simulator, a latent-space predictor, or a 3D-world generator. The diagram shows its signature shape.
NVIDIA
Full stack: simulate, model, train, deploy
An integrated, full-stack approach to physical AI: Omniverse and Isaac Sim build OpenUSD simulations and digital twins, Cosmos world foundation models predict and generate physical worlds, and Isaac Lab trains robot policies that transfer to real hardware.
The six dimensions, in detail
PerceptionIsaac Sim simulates cameras and sensors and generates annotated synthetic data (RGB, segmentation, bounding boxes) to train perception stacks; Cosmos Reason adds a vision-language model that reasons over scenes.
World modelCosmos world foundation models understand and simulate physical environments and predict future world states from text, image, video, and action inputs.
SimulationOmniverse and Isaac Sim build physically based simulations and digital twins on the OpenUSD scene standard, with PhysX / Newton physics and RTX rendering.
Policy & controlIsaac Lab is a GPU-accelerated framework for training robot policies at scale with reinforcement and imitation learning across humanoids, arms, and mobile robots.
Sim-to-realIsaac Sim ingests CAD, URDF, and real-world captures into USD and supports software- and hardware-in-the-loop, while Isaac Lab trains policies in sim to bridge the gap to deployment.
SafetySafety is mainly simulation-based validation before deployment, plus open content guardrails and SynthID watermarking across the Cosmos models; there is no single unified safety layer across the stack.
Runtime Serving: Cosmos world foundation models are available as NVIDIA NIM inference microservices (Cosmos Reason ships as a NIM) for production deployment across cloud, data centre, and workstation.
Hover or tap a node to trace its connections, or play the flow.
DeepMind Genie
Generative world model
A line of foundation world models that generate interactive, action-controllable, explorable environments from a prompt or image, used to simulate worlds and to train and evaluate embodied agents.
The six dimensions, in detail
PerceptionGenie takes a prompt image (Genie 2) or text (Genie 3) plus the user or agent's navigation actions; it synthesises a world frame by frame rather than sensing a real scene.
World modelGenie is a foundation world model: it generates action-controllable, explorable environments and lets an agent see how the world evolves as it acts.
SimulationThe model is the simulator: it generatively simulates interactive worlds (Genie 3 runs in real time at 720p and 24fps, consistent for a few minutes) rather than running a physics engine or digital twin.
Policy & controlGenie provides the environment, not the controller; a separate embodied agent (DeepMind's SIMA) is given goals and drives the world with navigation actions.
Sim-to-realNot a stated focus: Genie is used to train and evaluate agents in generated worlds (Genie 3 was shown evaluating the SIMA agent), with no claim of transferring policies onto real hardware.
SafetyGenie 3 was released only as a limited research preview to a small cohort of academics and creators while DeepMind develops safety mitigations and gathers feedback.
Hover or tap a node to trace its connections, or play the flow.
Meta V-JEPA
Latent-space video world model
A self-supervised video world model that learns by predicting in a latent representation space (not pixels); an action-conditioned variant enables zero-shot robot planning and control from goal images.
The six dimensions, in detail
PerceptionA self-supervised video encoder trained on over a million hours of video turns raw video into embeddings that capture the semantics of the observed world, with no human labels.
World modelV-JEPA 2 is a world model that predicts in an abstract latent representation space rather than reconstructing pixels, learning how objects move and interact.
SimulationNot a simulator or digital twin: it predicts future latent states, not pixel-level rollouts or a simulated environment.
Policy & controlAn action-conditioned variant (V-JEPA 2-AC), post-trained on about 62 hours of robot data, enables zero-shot planning and control by specifying goals as images.
Sim-to-realMeta reports deploying the model zero-shot on real robot arms for reaching, grasping, and pick-and-place (65-80% on new objects) without a simulator in the loop.
SafetyNo safety or guardrail mechanism is described in the official pages; the stated constraints are research limitations such as single-time-scale prediction.
Hover or tap a node to trace its connections, or play the flow.
World Labs
Generative 3D world models
A spatial-intelligence company building generative world models that turn a prompt, image, or video into persistent, explorable 3D worlds; focused on generation and reconstruction rather than robot control. (Press often calls these 'Large World Models'; the company's own term is 'world models'.)
The six dimensions, in detail
PerceptionIts models take multimodal input (a single image, text, video, panoramas, or multi-view) and reconstruct 3D structure, capturing layout, depth, lighting, and spatial form.
World modelThe core offering is generative world models that produce persistent, spatially consistent, explorable 3D worlds (Marble, and the real-time research preview RTFM).
SimulationMarble can reconstruct, generate, and simulate 3D worlds and export Gaussian splats, meshes, and low-fidelity collider meshes for coarse physics; outputs are 3D worlds and assets, not an industrial digital twin.
Policy & controlDocumented control is over the camera and viewpoint; the company's own taxonomy treats a planning-capable, action-producing world model as still aspirational, not shipped.
Sim-to-realNo sim-to-real transfer, robot deployment, or real-world policy validation is claimed in the official posts.
SafetyThe reviewed official pages do not document safety, guardrails, or usage-policy commitments.
Six questions every physical-AI system answers, with the world model as the lead lens.
Perception
How the system takes in the physical world: cameras, sensors, video, or multimodal capture turned into a usable representation.
NVIDIAIsaac Sim sensors + Cosmos Reason VLM
DeepMind GeniePrompt image / text + actions
Meta V-JEPASelf-supervised video encoder
World LabsMultimodal 3D reconstruction
World model
A learned model that predicts how a scene evolves and how actions change it, used to imagine or roll out future states.
NVIDIACosmos world foundation models
DeepMind GenieFoundation world model (core)
Meta V-JEPALatent-space video world model
World LabsGenerative 3D world models
Simulation
Physically based virtual environments and digital twins where behaviour is generated, rendered, and tested before the real world.
NVIDIAOmniverse + Isaac Sim (OpenUSD)
DeepMind GenieGenerative interactive worlds
Meta V-JEPANot a simulator / digital twin
World Labs3D worlds + collider meshes
Policy & control
How an embodied agent's actions are learned or produced: reinforcement and imitation learning, or planning toward a goal.
NVIDIAIsaac Lab RL / imitation
DeepMind GenieExternal agent (SIMA) drives it
Meta V-JEPAZero-shot goal-image planning
World LabsCamera control; no policy
Sim-to-real
Transferring behaviour learned in simulation or a world model onto real hardware, closing the gap to physical reality.
NVIDIAIsaac Sim + Isaac Lab transfer
DeepMind GenieNot a stated focus
Meta V-JEPAReal-robot zero-shot (no sim)
World LabsNot documented
Safety
Validating behaviour and constraining outputs: simulation-based testing, content guardrails, and staged, reviewed release.
NVIDIASim-based validation + Cosmos guardrails
DeepMind GenieLimited research preview
Meta V-JEPANo documented guardrails
World LabsNot documented
How to choose
Start from what you are building and match it to a stack below.
A full pipeline to simulate, train, and deploy real robotsNVIDIA
Generate interactive worlds to train and evaluate embodied agentsDeepMind Genie
Learn a predictive world model from video and act zero-shot on a robotMeta V-JEPA
Generate explorable 3D worlds and assets from an image or promptWorld Labs
Validated against official documentation, 2026. Several stacks are research previews; capabilities a stack does not claim are marked as such. Cosmos model-family names are per NVIDIA's GitHub and newsroom; 'Large World Models' is press framing, not World Labs' own term.
Companion map
Agentic coding tools
Agentic coding tools are mapped across six dimensions - surface, autonomy, context, execution, extensibility, and control - that capture where a tool runs, how much it acts on its own, how it knows your codebase, what it can do, how you extend it, and how its actions are reviewed and bounded. These tools change quickly, so durable model versions are left to the live docs.
Agentic coding tools maps
Each tool carries the work differently: a terminal-first agent, an editor that spans completion to agent mode, an agent that runs locally and in the cloud, agentic coding woven into GitHub, or a standalone agent-first IDE. The diagram shows its signature shape.
Claude Code
Agentic CLI + IDE coding tool
Anthropic's agentic coding tool, powered by Claude models, that reads a codebase, edits files, runs commands, and integrates with development tools across the terminal, IDEs, a desktop app, and the browser. The same engine, CLAUDE.md, settings, and MCP servers work across every surface.
The six dimensions, in detail
SurfaceRuns as a terminal CLI, a VS Code extension (and Cursor), a JetBrains plugin, a standalone desktop app, and in the browser; the same engine, CLAUDE.md, settings, and MCP servers work across surfaces, and it also integrates with GitHub Actions / GitLab CI, Slack, and Chrome.
AutonomyAn autonomous multi-step agent: from a single natural-language request it plans, edits across multiple files, runs commands, and verifies results rather than offering inline autocomplete. Plan mode, subagents, background / cloud agents, and scheduled routines extend longer-running autonomy.
ContextUses agentic search to understand the whole codebase without manual context selection. Persistent context comes from CLAUDE.md files (managed, user, project, and local scopes loaded every session) and auto memory it writes per project; rules files allow path-scoped instructions.
ExecutionReads, edits, and writes files, makes coordinated multi-file changes, runs terminal commands, runs tests and builds, and uses git to commit, branch, and open PRs. Chrome integration enables debugging live web apps, and MCP adds external tool actions.
ExtensibilityConnects external tools via MCP servers (streamable HTTP or local stdio), and supports subagents, skills and custom slash commands, hooks at many lifecycle events, plugins and marketplaces, and the Agent SDK for building custom agents.
ControlA tiered permission system with allow / ask / deny rules (deny-first) managed via /permissions, plus permission modes (default, accept edits, plan, and bypass). The default mode prompts for approval before edits and commands; PreToolUse hooks can block calls, OS-level sandboxing restricts Bash, and managed policy settings give enterprises centralized control.
Hover or tap a node to trace its connections, or play the flow.
OpenAI Codex
Coding agent, everywhere you code
OpenAI's agentic coding tool that reads, edits, and runs code, available as an open-source terminal CLI, an IDE extension, and a cloud / async agent, with GitHub and Slack integrations and a ChatGPT app surface. Its docs recommend a current OpenAI coding model rather than fixing a default.
The six dimensions, in detail
SurfaceMulti-surface: an open-source terminal CLI built in Rust (via npm, Homebrew, or an install script), an IDE extension for VS Code (and Cursor / Windsurf), a cloud / web agent, plus GitHub and Slack integrations and a ChatGPT app surface.
AutonomyAn autonomous multi-step coding agent that can read, edit, and run code locally or in the cloud; the cloud agent runs tasks in the background and in parallel in its own environment and can be delegated work via @codex on GitHub.
ContextReads repository context in the working directory and layers AGENTS.md instruction files (a global file, the project root, and nested directories) into a precedence-ordered prompt chain; cloud runs let you define repositories and setup steps.
ExecutionEdits files, runs terminal commands, and runs and tests code across multiple files within the selected workspace; cloud environments can be configured with tools and admin-gated internet access, and recent releases add browser use via the Chrome DevTools Protocol.
ExtensibilityActs as an MCP client and can run as an MCP server (MCP support is experimental), configured through its config file; supports built-in slash commands, subagent threads, and lifecycle hooks.
ControlHuman-in-the-loop is enforced by combining a sandbox mode (read-only, workspace-write, or full access) with an approval policy, exposed as Read Only, Auto, and Full Access presets and managed via the /permissions command; full access requires an explicit bypass flag, and admins control cloud internet access.
Hover or tap a node to trace its connections, or play the flow.
Cursor
AI-native editor (VS Code fork)
An AI-native code editor by Anysphere, built as a fork of VS Code, that combines Tab autocomplete, AI chat, and an autonomous multi-step Agent mode. It is multi-model, letting you pick the model behind chat and the agent.
The six dimensions, in detail
SurfaceA standalone AI-native desktop IDE built as a fork of VS Code, so it retains VS Code extensions, themes, and keybindings. It also offers Cursor web / desktop cloud agents, a CLI, and integrations via Slack, GitHub, and Linear.
AutonomySpans the full range: Tab inline autocomplete, conversational chat, and an Agent mode that autonomously plans and executes multi-step tasks with many tool calls. Cloud Agents extend this to asynchronous, parallel, remote execution.
ContextIndexes the codebase into vector embeddings for semantic retrieval, re-synced periodically and respecting .gitignore / .cursorignore. Persistent context and memory come from Rules (.cursor/rules files, user and team rules, and AGENTS.md) included in model context.
ExecutionThe agent edits multiple files, runs and monitors terminal commands, performs codebase and web search, reads images, and controls a browser to screenshot and test apps. Cloud Agents run full dev environments in VMs and open PRs.
ExtensibilityFirst-class MCP support via .cursor/mcp.json (stdio, SSE, and streamable HTTP, with OAuth). Extended by the VS Code extension ecosystem, Rules, AGENTS.md, a CLI, skills, and a Cloud Agents API; multi-model with a model picker.
ControlCheckpoints (automatic snapshots you can preview and restore), terminal sandboxing with auto-review, allowlist, and run-everything modes, configurable permissions for deletes, dotfiles, browser, and external files, plus enterprise-enforced policies. Cloud Agent output is reviewed as PRs.
Hover or tap a node to trace its connections, or play the flow.
GitHub Copilot
Completion to autonomous coding agent
GitHub's AI coding assistant spanning IDE code completion, chat, in-editor agent mode, an asynchronous cloud coding agent, a CLI, and integrations on github.com and mobile. It is multi-model with a model picker.
The six dimensions, in detail
SurfaceRuns as IDE extensions (VS Code, Visual Studio, JetBrains, Vim / Neovim, Xcode, Eclipse, and Zed), as a Copilot CLI in the terminal, natively on github.com, and in GitHub Mobile. Surfaces range from a local editor plugin to a fully cloud-hosted async agent.
AutonomySpans the full spectrum: inline code completion, then Copilot Chat (Q&A), then an in-IDE agent mode that determines files, proposes edits and terminal commands, and iterates, up to the asynchronous Copilot coding agent that researches a repo, plans, makes changes on a branch, and opens a PR.
ContextStanding context comes from repository custom instructions in .github/copilot-instructions.md and reusable Markdown prompt files; chat can reference code and repositories, and Copilot Spaces act as a shared source of truth from docs and repos. The docs describe codebase awareness without committing to a persistent semantic index.
ExecutionAgent mode edits multiple files, proposes and runs terminal commands, and iterates to fix errors in the local environment; the cloud agent runs in an ephemeral GitHub Actions environment where it can explore code, make changes, run tests and linters, then open a PR.
ExtensibilitySupports MCP across IDEs, the CLI, the Copilot app, and github.com agents, plus a first-party GitHub MCP server and a curated MCP registry; extensibility also includes custom instructions and prompt files. Multi-model with a model picker.
ControlHuman-in-the-loop is preserved: agent-mode edits and terminal commands are proposed for user approval, and the cloud agent's changes land on a branch and PR that a human reviews before merge. Repository rulesets and branch protections constrain the cloud agent, and Copilot code review adds AI review on PRs.
Hover or tap a node to trace its connections, or play the flow.
Google Antigravity
Agent-first development platform
Google's agent-first development platform: a standalone IDE where AI agents plan, execute, and verify software tasks across the editor, terminal, and browser, with an Agent Manager surface for orchestrating them. At launch (Nov 2025) it shipped in free public preview with a lineup including Gemini 3 Pro, Claude Sonnet 4.5, and GPT-OSS.
The six dimensions, in detail
SurfaceA standalone cross-platform desktop application (an agent-first, VS Code-style IDE) for macOS, Windows, and Linux, presenting two surfaces: an Editor View and an agent-orchestration Manager surface; agents also drive the terminal and a Chrome browser. Launched in public preview in November 2025.
AutonomySpans the full range: inline tab completion and inline commands in the Editor View, up to autonomous multi-step agents that plan, execute, and verify complex tasks end-to-end and run asynchronously in the Manager surface.
ContextCodebase-aware agents operating within workspaces; it treats learning as a core primitive, letting agents save useful context and code snippets to a knowledge base to improve future tasks.
ExecutionAgents act across the editor (multi-file code edits, tab completions, and inline commands), the terminal (for example launching the app), and the browser (testing and verifying via Chrome, producing browser recordings).
ExtensibilitySupports MCP with local and remote servers (stdio, SSE, and streamable HTTP) via an MCP Store with one-click Google Cloud integrations and a user-editable config file, plus per-project control over which MCP tools are exposed to the agent.
ControlHuman-in-the-loop via Artifacts (task lists, plans, screenshots, and browser recordings) reviewed at a glance with Google-Docs-style comments the agent incorporates without halting; the permissions docs describe an Ask mode with allow / deny rules, and browser actions require explicit Chrome debugging permission.
Validated against official documentation, June 2026; these tools change quickly. Model version numbers are deliberately left to the live docs, and capabilities a tool does not document are omitted rather than overstated. Sources: Claude Code (https://code.claude.com/docs/en/overview), OpenAI Codex (https://developers.openai.com/codex/), Cursor (https://docs.cursor.com), GitHub Copilot (https://docs.github.com/en/copilot), and Google Antigravity (https://antigravity.google).
Validated against official documentation, 2026. Machine readable at /api/atlas.