The Multi-Agent Landscape: How Every Major Coding Agent Does Multi-Agent Collaboration in 2026

TL;DRBy 2026 nearly every mainstream coding agent supports subagents. Design philosophies split three ways: deterministic scripted orchestration (Claude Code Workflow), model-driven autonomy (Codex, Devin), and IDE command-center integration (Windsurf 2.0, VS Code). This overview maps product positioning, a capability matrix, and the design-philosophy spectrum.

In 2026, "letting an AI agent call another AI agent for help" has gone from experimental feature to table stakes. From CLI tools to IDEs, open-source frameworks to cloud services, nearly every player offers some form of multi-agent support.

But the design philosophies vary wildly — some let you write JavaScript scripts to control every step precisely, while others let the LLM decide on its own whether to spawn a subagent. This is the series overview for Multi-Agent Systems in Practice, mapping each product's positioning and capabilities to help you decide which model fits your use case.

CLI / Terminal Agents

Claude Code (Anthropic)

According to the official Anthropic documentation, Claude Code's multi-agent system has four layers:

Subagents — Fork (inherits full context + shares prompt cache) or Fresh (zero context, independent judgment)
Skills — Predefined prompt-template-driven tasks
Agent Teams — A small number of peer sessions negotiating in real time
Dynamic Workflows — Deterministic JS-scripted orchestration, currently the most complete multi-agent orchestration system

Workflows provide five core primitives: pipeline() (per-item pipeline, no barrier), parallel() (barrier sync), agent({schema}) (structured output), phase() / log() (progress grouping), and budget.remaining() (token budget tracking). A single run supports up to 1,000 agents with 16 concurrent, and resume after interruption.

Claude Code's distinguishing feature is supporting both scripted and model-driven modes simultaneously — Workflows handle deterministic processes while Subagents and Agent Teams handle autonomous exploration.

Codex CLI (OpenAI)

According to the official Codex announcement (GA March 2026), Codex follows a Manager / Worker model. The manager agent makes decisions and controls workers with six primitives: spawn_agent, send_message, followup_task, wait_agent, list_agents, close_agent.

Three built-in agent types: default, worker (implementation-oriented), and explorer (read-only exploration). Defined in .codex/agents/<name>.toml or AGENTS.md.

Symphony is OpenAI's open-source orchestration layer that uses Linear as a control plane to map issues to Codex agents — but this is an always-on issue-driven model, not in-session multi-agent.

Antigravity (formerly Gemini CLI, Google)

Gemini CLI was officially retired on 2026-06-18 and renamed to Antigravity, rewritten in Go with new multi-agent background orchestration. The existing subagent architecture carries over the Hub-and-Spoke model: the main agent dispatches using @agent syntax, with built-in @generalist, @cli_help, and @codebase_investigator agents.

Antigravity's distinguishing feature is compressing results before returning them to the main session, preventing subagent output from polluting the parent context. Each subagent has its own independent context and tool set.

Aider

Currently no multi-agent support. Single-agent sequential processing; its strength is being extremely lightweight and supporting nearly every LLM vendor. The community has proposed /spawn and /delegate but neither is implemented yet.

IDE Agents

Cursor

According to the Cursor 3.2 changelog (April 2026), Cursor is shifting from "editor" to "agent execution runtime":

Subagents (Cursor 2.4, Jan 2026): Spawn multiple independent-context Claude instances running in parallel
/multitask (Cursor 3.2): Automatically breaks large tasks into chunks and assigns them to subagents
Background Agents: Run in cloud sandboxes, producing output as PRs for review

Windsurf (Codeium → acquired by Devin)

Windsurf's strategy is not to build its own multi-agent orchestration but to serve as a command center:

Cascade: Core agent, persistent context-aware, breaks tasks into Flows
Wave 13 (Dec 2025): Parallel multiple Cascade sessions (up to 5), each with git worktree isolation
Windsurf 2.0 (April 2026): Agent Command Center (Kanban-style multi-agent dashboard) + native Devin integration

Cascade handles real-time local work (low latency); long-running tasks are handed off to Devin's cloud VM with one click.

VS Code Agent Sessions (Microsoft)

VS Code 1.109 (Feb 2026) introduced Multi-Agent Development, allowing multiple different agents to run in parallel within the same IDE — mix and match Copilot + Claude + Codex. This is an IDE-layer multi-agent framework, not any individual agent's subagent architecture.

Cloud / Async Agents

GitHub Copilot Coding Agent

Each task runs in a GitHub Actions runner sandbox: receive Issue → work autonomously → produce PR. No native subagent support; multi-agent capabilities come from VS Code Agent Sessions.

Jules (Google)

Each task executes in a Google-managed independent cloud VM. Four internal stages: Planning (Gemini 2.5 Pro) → Execution → Critique (added Aug 2025) → Testing. Officially described as "internal workflow stages"; users don't directly control the orchestration.

Devin (Cognition)

Fusion architecture (June 2026): Two parallel agents — a frontier "lead" model + a cheaper "sidekick" model, each with independent toolsets and context. Full VM with desktop, browser, and computer-use capabilities.

Multi-Agent Development Frameworks

LangGraph (LangChain)

Graph state machine: State (snapshot) → Node (execution) → Edge (flow). Four modes: subagents (supervisor delegation), handoffs (transfer), routers (routing), and custom workflows. According to LangChain's official benchmark, mixing model tiers can reduce costs.

CrewAI

Role-playing framework: Each Agent has a role, goal, and backstory. Two process types: sequential and hierarchical (manager auto-delegates). Fastest-growing community in 2026.

Microsoft Agent Framework (MAF)

GA in April 2026, merging AutoGen + Semantic Kernel. AutoGen entered maintenance mode. Supports sequential / concurrent / handoff / group chat / Magentic-One orchestration patterns, with graph-based workflows for explicit multi-agent orchestration.

The original AutoGen community fork AG2 continues independent development, preserving the 0.2 API.

Capability Matrix

Capability	Claude Code	Codex	Cursor	Windsurf	Antigravity	Copilot	Jules	Devin
Subagent	Fork + Fresh	6 primitives	/multitask	Multi Cascade	@agent	—	Internal 4-stage	Fusion
Scripted orchestration	JS Workflow	—	—	—	—	—	—	—
Model-driven	Agent Teams	Manager/Worker	Parent/Child	Cascade Flows	Hub-and-Spoke	—	Internal	Orchestrator
Context inheritance	Fork inherits	Independent	Independent	Cascade persistent	Compressed return	—	—	Independent
Structured output	`agent({schema})`	—	—	—	—	—	—	—
Budget tracking	`budget.remaining()`	—	—	—	—	—	—	—
Cloud agent	remote	Sandbox container	Background	Devin VM	—	Actions runner	Google VM	Full VM

Design Philosophy Spectrum

Who controls orchestration? From left (deterministic script) to right (fully model-autonomous):

Deterministic Script ◄──────────────────────────────────► Model-driven Autonomy

LangGraph    Claude Code    CrewAI    Cursor    Codex    Devin    AutoGen
  Graph SM    Workflow       Roles+    /multitask  Manager   Fusion   GroupChat
              JS script     Delegation            /Worker   lead/    Free chat
                                                  sidekick

The scripted camp treats orchestration as infrastructure — deterministic flow, resumable, budget-trackable. Suited for repeatable, auditable workflows.

The model-driven camp lets the LLM autonomously decide when to spawn and aggregate. Highly flexible but unpredictable; suited for exploratory tasks.

The hybrid camp (Windsurf 2.0, VS Code) doesn't build its own orchestration but serves as a "command center" integrating agents from multiple vendors.

Another trend is internal multi-agent — Jules's 4-stage pipeline and Devin's lead/sidekick present a single-agent interface to users while multiple specialized agents collaborate internally.

Series Guide

This is the first article in the Multi-Agent Systems in Practice series. Subsequent articles dive deep into individual topics:

Cost Control: How parallel spawning + nesting depth burns money, defense mechanisms from seven frameworks, the industry consensus of "soft landing before hard stop"
Orchestration Patterns: Scripted vs model-driven vs hybrid — how to choose
Context Isolation and Sharing: fork vs fresh, history truncation, result compression
Agent Communication: Mailbox, handoff, delegate, and the A2A/MCP protocols
Observability: How to debug multi-agent systems and know where the money goes
Safety and Guardrails: Preventing prompt injection from propagating across agents, permission isolation