Planning Structures in Current AI Systems
March 2026
1. Introduction
The period from late 2024 through early 2026 has seen a rapid transition in AI systems from single-model, prompt-response architectures to coordinated multi-agent systems capable of planning, delegating, and executing complex workflows. This report examines the current state of the art in how these multi-agent infrastructures are structured, with a focus on planning architectures, coordination protocols, and the frameworks through which companies deploy and develop these systems.
The scope is restricted to multi-agent systems as currently deployed or under active development by industry participants. Single-agent tool-use patterns are excluded except where they serve as components of multi-agent designs.
2. Dominant Planning Architectures
Current multi-agent systems exhibit several recurring planning structures. These are not mutually exclusive; production systems frequently combine them.
2.1 Plan-and-Execute (Planner-Executor Separation)
The most widely adopted planning pattern separates an LLM-powered planner from one or more executor agents. LangChain’s documentation describes three variants of this architecture: a basic plan-and-solve approach (loosely based on Wang et al.’s Plan-and-Solve Prompting and Yohei Nakajima’s BabyAGI), a ReWOO variant, and the LLMCompiler [1]. In the basic form, a planner generates a multi-step plan, executors carry out individual steps, and the planner is re-invoked for replanning if the initial plan did not produce the desired outcome [1].
The LLMCompiler variant, based on Kim et al., introduces a DAG-based task representation where each task includes a tool, arguments, and a dependency list. A Task Fetching Unit schedules tasks as their dependencies are met, enabling parallel execution. A Joiner component then decides whether to respond with a final answer or replan [1]. LangChain claims a 3.6x speed improvement from this parallelism [1].
LangChain’s documentation for LangGraph describes this as a general pattern where orchestrator-worker workflows use a Send API to dynamically create worker nodes with individual state, while all worker outputs are written to a shared state key accessible to the orchestrator [2].
2.2 Directed Graph (DAG and Cyclic Graph) Workflows
LangGraph structures workflows as directed graphs where nodes represent agents or processing steps and edges control data flow [3]. The framework supports both DAG (directed acyclic graph) structures for linear pipelines and cyclic graphs that allow loops, retries, and iterative refinement [3][4]. A centralized StateGraph maintains context, stores intermediate results, and enables parallel execution and conditional branching [5].
Google’s Agent Development Kit (ADK), introduced at Google Cloud NEXT 2025, provides explicit workflow agents — SequentialAgent, ParallelAgent, and LoopAgent — for predictable pipelines, alongside LLM-driven dynamic routing for adaptive behavior [6]. ADK organizes agents in a hierarchy where parent agents manage sub-agents, and each agent can have only one parent [7].
2.3 Role-Based Crew Orchestration
CrewAI implements a role-based metaphor where agents are assigned roles, goals, and backstories, then organized into “crews” [8]. It offers two primary process paradigms: Sequential (assembly-line task chaining) and Hierarchical (a manager agent dynamically delegates to specialists) [9]. When CrewAI’s planning feature is enabled, the system generates a step-by-step workflow before agents begin execution, and this plan is injected into each task so all agents share the same roadmap [10].
MetaGPT takes a similar approach specifically for software development, simulating a full-stack product team — project managers, tech leads, developers, and analysts — as coordinated agents following standardized engineering workflows [11].
2.4 Conversation-as-Coordination
Microsoft’s AutoGen framework (and its successor, the Microsoft Agent Framework) treats complex workflows as dialogues among multiple agents [12]. Each agent is “conversable” — capable of sending and receiving messages — and the system supports both fully autonomous conversations and human-in-the-loop patterns [12]. AutoGen v0.4 adopted an asynchronous, event-driven architecture to enable broader agentic scenarios [13].
In October 2025, Microsoft released the Microsoft Agent Framework in public preview, merging AutoGen’s multi-agent orchestration with Semantic Kernel’s production foundations [14]. The unified framework introduced a graph-based workflow API for defining multi-step, multi-agent workflows, while retaining AutoGen’s orchestration patterns including group chat, debate, and reflection [14][15].
2.5 Handoff-Based Routing
OpenAI’s approach, embodied first in the experimental Swarm framework (October 2024) and then the production-ready Agents SDK (March 2025), uses a lightweight handoff model [16][17]. Each agent encapsulates instructions and tools; when one agent determines it cannot handle a request, it transfers control to another agent via an explicit handoff function [16]. The Agents SDK added guardrails, MCP server tool calling, persistent sessions, and built-in tracing [17].
This stateless, handoff-centric design contrasts with the stateful graph architectures of LangGraph. As one review noted, Swarm keeps exactly one agent in charge at any time through clear message passing, with no persistent state between calls [18].
3. Inter-Agent Communication Protocols
A critical development in 2025 was the emergence of standardized protocols for agent communication.
3.1 Model Context Protocol (MCP)
Anthropic introduced MCP in November 2024 as an open standard for connecting AI assistants to external data sources and tools [19]. MCP standardizes agent-to-tool communication — how an agent connects to APIs, databases, and external services [20]. By March 2025, OpenAI had adopted MCP across its Agents SDK, Responses API, and ChatGPT desktop [21]. Google DeepMind confirmed MCP support in April 2025 [21].
In December 2025, Anthropic donated MCP to the Agentic AI Foundation (AAIF) under the Linux Foundation, co-founded by Anthropic, Block, and OpenAI [22]. By that point, MCP had over 97 million monthly SDK downloads across Python and TypeScript, more than 5,800 MCP servers, and 300+ MCP clients [23].
A notable scaling challenge emerged as MCP adoption grew: loading all tool definitions upfront into the context window becomes expensive as the number of connected tools increases. Anthropic’s engineering team described a code-execution pattern where agents generate scripts that call MCP tools on-demand rather than loading all tool definitions upfront, conserving context and reducing latency [24].
3.2 Agent2Agent Protocol (A2A)
Google launched A2A in April 2025 at Cloud Next, with support from over 50 technology partners [25]. A2A addresses agent-to-agent communication — enabling agents from different vendors and frameworks to discover each other, negotiate tasks, and coordinate actions [25]. Core primitives include Agent Cards (JSON-based capability advertisements), task management with defined lifecycle states, and user experience negotiation [25].
A2A was donated to the Linux Foundation in June 2025 [26]. Version 0.3, released July 31, 2025, added gRPC support and signed security cards, with over 150 supporting organizations [27].
However, A2A’s adoption trajectory has been debated. One analysis from September 2025 argued that MCP gained grassroots developer momentum while A2A required building new infrastructure, and that by late 2025 most of the ecosystem had consolidated around MCP for practical purposes [28]. Others note A2A remains active in enterprise contexts with partners like Adobe, ServiceNow, and S&P Global [27].
3.3 Agent Communication Protocol (ACP)
IBM Research launched ACP in March 2025 to power its open-source BeeAI platform [29]. ACP uses REST-based communication with HTTP endpoints, supports both synchronous and asynchronous messaging, and requires no dedicated SDK [30]. IBM positioned ACP as complementary to MCP: where MCP connects agents to tools, ACP connects agents to each other [31].
In August 2025, ACP merged with A2A under the Linux Foundation [32]. IBM’s Kate Blair joined the A2A Technical Steering Committee, and the BeeAI platform transitioned from ACP to A2A as its communication layer [32].
3.4 Protocol Layering
The current consensus positions these protocols as complementary layers rather than competitors. MCP handles agent-to-tool communication; A2A (now incorporating ACP’s contributions) handles agent-to-agent communication [20][25]. As IBM described it, in a multi-agent system MCP connects each agent to its tools, while ACP/A2A connects agents to each other to share results, compare data, and coordinate decisions [31].
4. Major Framework Implementations
4.1 LangGraph (LangChain)
LangGraph extends LangChain with a graph abstraction for stateful, multi-agent applications [3]. Key features include:
- Persistent shared state across workflows via
StateGraph[5] - Support for cyclic graphs enabling loops, retries, and iterative refinement [4]
- Human-in-the-loop integration via interrupt points and state editing [33]
- Subgraphs for modular, reusable agent groupings [5]
- Orchestrator-worker patterns with the
SendAPI for parallel dynamic worker creation [2]
LangGraph supports Reflection, Reflexion, and ReAct agent patterns [3]. Production deployments use checkpointing (e.g., PostgresSaver) for durable execution across failures [4].
4.2 CrewAI
CrewAI uses a role-based architecture with YAML-driven agent configuration [8]. Its “Flows” feature, added for production use, provides event-driven control with logical operators (or_, and_) for combining conditions across workflow triggers [8]. CrewAI claims over 100,000 certified developers and integrations with over 1,200 applications [8]. The CrewAI AMP Suite offers enterprise deployment with tracing, a unified control plane, and on-premise or private VPC deployment options [8].
4.3 Microsoft Agent Framework
Released in public preview on October 1, 2025, this framework merges AutoGen and Semantic Kernel [14]. It supports both Python and .NET, and introduces a graph-based workflow API on top of AutoGen’s orchestration patterns [14]. The framework emphasizes open standards — MCP, A2A, and OpenAPI — with native observability via OpenTelemetry and Azure Monitor integration [15]. AutoGen and Semantic Kernel entered maintenance mode (bug fixes and security patches only) following the merge [34].
4.4 Google Agent Development Kit (ADK)
ADK was introduced at Google Cloud NEXT 2025 and open-sourced [35]. It provides three agent types: LLM Agents (language-based reasoning), Workflow Agents (orchestration via Sequential, Parallel, Loop patterns), and Custom Agents (user-defined logic) [7]. ADK is the same framework powering agents within Google products like Agentspace and Google Customer Engagement Suite [35]. TypeScript support was added in December 2025 [36].
4.5 OpenAI Agents SDK
Launched in March 2025 as a production evolution of the experimental Swarm project [17]. Core primitives are Agents, Handoffs, and Guardrails. It is provider-agnostic (works with 100+ LLMs via the Chat Completions API) though optimized for OpenAI models [37]. The SDK lacks built-in durable or semantic memory, requiring external solutions for cross-session persistence [37].
5. Governance and Standardization
The formation of the Agentic AI Foundation (AAIF) under the Linux Foundation in December 2025 represents a significant governance milestone [22]. Founding contributions include Anthropic’s MCP, Block’s goose (an open-source agent framework), and OpenAI’s AGENTS.md (a standard for giving coding agents project-specific guidance, adopted by over 60,000 open-source projects) [22]. Platinum members include AWS, Anthropic, Block, Bloomberg, Cloudflare, Google, Microsoft, and OpenAI [22].
A2A was separately contributed to the Linux Foundation in June 2025 [26], and ACP merged into A2A in August 2025 [32].
6. Observed Patterns and Open Problems
Several structural patterns recur across implementations:
Hierarchical delegation is the dominant coordination model. Whether via LangGraph’s orchestrator-worker pattern [2], CrewAI’s hierarchical process [9], ADK’s parent-sub_agent hierarchy [7], or Microsoft Agent Framework’s graph-based workflows [14], the common structure is a coordinator that decomposes tasks and delegates to specialists.
Explicit planning before execution is becoming standard for complex workflows. The plan-and-execute separation described by LangChain [1], CrewAI’s planning feature [10], and ADK’s workflow agents [6] all reflect a shift from reactive (ReAct-style) to proactive planning. The claimed advantages include faster multi-step execution (the planner is not consulted after each action), cost savings (sub-tasks can use smaller models), and higher task completion rates from forcing explicit reasoning about all required steps [1].
State management remains a primary engineering challenge. LangGraph uses persistent checkpointing [4]; AutoGen/Microsoft Agent Framework uses session-based state management [14]; OpenAI’s Agents SDK is explicitly stateless between calls [18]. One analysis noted that over 75% of multi-agent systems become increasingly difficult to manage once they exceed five agents, due to exponential growth in monitoring complexity [5].
Protocol convergence is underway but incomplete. MCP has achieved near-universal adoption for agent-to-tool communication [23]. Agent-to-agent communication is consolidating around A2A but with slower adoption than MCP [28]. The question of whether A2A will achieve comparable ubiquity remains open.
Human-in-the-loop integration is consistently emphasized but implemented differently. LangGraph uses interrupt points and state editing [33]; CrewAI uses webhook-based pauses [9]; Microsoft Agent Framework builds it into its workflow API [14]. The maturity of HITL mechanisms varies significantly across frameworks.
Bibliography
[1] LangChain. “Plan-and-Execute Agents.” LangChain Blog, February 2024. [Snippet] https://blog.langchain.com/planning-agents/
[2] LangChain. “Workflows and Agents.” LangChain Documentation. [Snippet] https://docs.langchain.com/oss/python/langgraph/workflows-agents
[3] Debroy, S. “LangGraph — Architecture and Design.” Medium, August 2025. [Snippet] https://medium.com/@shuv.sdr/langgraph-architecture-and-design-280c365aaf2c
[4] Pradhan, A. “Scalable Agentic AI in 2025: Why LangGraph is the Foundation for the Agentic Startup.” Medium, December 2025. [Snippet] https://medium.com/@ap3617180/scalable-agentic-ai-in-2025-why-langgraph-is-the-foundation-for-the-agentic-startup-e30f3c409339
[5] Latenode Blog. “LangGraph Multi-Agent Orchestration: Complete Framework Guide + Architecture Analysis 2025.” February 2026. [Snippet] https://latenode.com/blog/ai-frameworks-technical-infrastructure/langgraph-multi-agent-orchestration/langgraph-multi-agent-orchestration-complete-framework-guide-architecture-analysis-2025
[6] Google. “Agent Development Kit Documentation.” [Verified] https://google.github.io/adk-docs/
[7] Google. “Agents — Agent Development Kit (ADK).” [Verified] https://google.github.io/adk-docs/agents/
[8] CrewAI Inc. GitHub Repository. [Snippet] https://github.com/crewAIInc/crewAI
[9] Endo, T. “CrewAI: Scaling Human-Centric AI Agents in Production.” Medium, July 2025. [Snippet] https://medium.com/@takafumi.endo/crewai-scaling-human-centric-ai-agents-in-production-a023e0be7af9
[10] Kumari, J. “Using CrewAI Planning to Build a Structured Multi-Agent Workflow.” Analytics Vidhya, December 2025. [Snippet] https://www.analyticsvidhya.com/blog/2025/12/crewai-planning/
[11] Intuz. “Top 5 AI Agent Frameworks in 2026.” March 2026. [Snippet] https://www.intuz.com/blog/top-5-ai-agent-frameworks-2025
[12] Microsoft. “Multi-agent Conversation Framework — AutoGen 0.2.” [Snippet] https://microsoft.github.io/autogen/0.2/docs/Use-Cases/agent_chat/
[13] Microsoft Research. “AutoGen.” [Snippet] https://www.microsoft.com/en-us/research/project/autogen/
[14] European AI & Cloud Summit. “Microsoft Agent Framework: The production-ready convergence of AutoGen and Semantic Kernel.” [Snippet] https://cloudsummit.eu/blog/microsoft-agent-framework-production-ready-convergence-autogen-semantic-kernel
[15] Visual Studio Magazine. “Semantic Kernel + AutoGen = Open-Source ‘Microsoft Agent Framework.’” October 2025. [Snippet] https://visualstudiomagazine.com/articles/2025/10/01/semantic-kernel-autogen--open-source-microsoft-agent-framework.aspx
[16] OpenAI. Swarm GitHub Repository. [Verified] https://github.com/openai/swarm
[17] OpenAI. “OpenAI Agents SDK.” [Verified] https://openai.github.io/openai-agents-python/
[18] Galileo. “OpenAI Swarm Framework Guide for Reliable Multi-Agents.” August 2025. [Snippet] https://galileo.ai/blog/openai-swarm-framework-multi-agents
[19] Anthropic. “Introducing the Model Context Protocol.” November 2024. [Snippet] https://www.anthropic.com/news/model-context-protocol
[20] IBM. “What Is Agent2Agent (A2A) Protocol?” [Snippet] https://www.ibm.com/think/topics/agent2agent-protocol
[21] Pento. “A Year of MCP: From Internal Experiment to Industry Standard.” [Snippet] https://www.pento.ai/blog/a-year-of-mcp-2025-review
[22] Linux Foundation. “Linux Foundation Announces the Formation of the Agentic AI Foundation (AAIF).” December 9, 2025. [Snippet] https://www.linuxfoundation.org/press/linux-foundation-announces-the-formation-of-the-agentic-ai-foundation
[23] Gupta, D. “Model Context Protocol (MCP) Guide: Enterprise Adoption 2025.” December 2025. [Snippet] https://guptadeepak.com/the-complete-guide-to-model-context-protocol-mcp-enterprise-adoption-market-trends-and-implementation-strategies/
[24] Anthropic. “Code Execution with MCP.” [Snippet] https://www.anthropic.com/engineering/code-execution-with-mcp
[25] Google Developers Blog. “Announcing the Agent2Agent Protocol (A2A).” April 9, 2025. [Snippet] https://developers.googleblog.com/en/a2a-a-new-era-of-agent-interoperability/
[26] Linux Foundation. “Linux Foundation Launches the Agent2Agent Protocol Project.” June 23, 2025. [Snippet] https://www.linuxfoundation.org/press/linux-foundation-launches-the-agent2agent-protocol-project-to-enable-secure-intelligent-communication-between-ai-agents
[27] Google Cloud Blog. “Agent2Agent Protocol (A2A) is Getting an Upgrade.” July 31, 2025. [Snippet] https://cloud.google.com/blog/products/ai-machine-learning/agent2agent-protocol-is-getting-an-upgrade
[28] fka.dev. “What Happened to Google’s A2A?” September 2025. [Snippet] https://blog.fka.dev/blog/2025-09-11-what-happened-to-googles-a2a/
[29] IBM Research. “Introducing Multiagent BeeAI.” May 2025. [Snippet] https://research.ibm.com/blog/multiagent-bee-ai
[30] IBM Research. “Agent Communication Protocol (ACP).” [Snippet] https://research.ibm.com/projects/agent-communication-protocol
[31] IBM Research. “An Open-Source Protocol for AI Agents to Interact.” May 2025. [Snippet] https://research.ibm.com/blog/agent-communication-protocol-ai
[32] LF AI & Data. “ACP Joins Forces with A2A.” August 2025. [Snippet] https://lfaidata.foundation/communityblog/2025/08/29/acp-joins-forces-with-a2a-under-the-linux-foundations-lf-ai-data/
[33] Latenode Blog. “LangGraph AI Framework 2025: Complete Architecture Guide.” February 2026. [Snippet] https://latenode.com/blog/ai-frameworks-technical-infrastructure/langgraph-multi-agent-orchestration/langgraph-ai-framework-2025-complete-architecture-guide-multi-agent-orchestration-analysis
[34] Microsoft. AutoGen GitHub Discussion #7066. [Snippet] https://github.com/microsoft/autogen/discussions/7066
[35] Google Developers Blog. “Agent Development Kit: Making It Easy to Build Multi-Agent Applications.” April 9, 2025. [Snippet] https://developers.googleblog.com/en/agent-development-kit-easy-to-build-multi-agent-applications/
[36] Google Developers Blog. “Introducing Agent Development Kit for TypeScript.” December 17, 2025. [Snippet] https://developers.googleblog.com/introducing-agent-development-kit-for-typescript-build-ai-agents-with-the-power-of-a-code-first-approach/
[37] Mem0. “OpenAI Agents SDK Review (December 2025).” [Snippet] https://mem0.ai/blog/openai-agents-sdk-review