+-----------------------------------------------------------------------------------------+
|                  Enterprise Multi-Agent Framework Comparison (2026)                     |
+-----------------------------------------------------------------------------------------+

LANGGRAPH (The Production State Machine Standard)
- Core Model: Stateful Directed Cyclic Graphs (Nodes, Edges, Reducers).
- Key Capabilities: Native persistence, Time-Travel debugging, Human-in-the-Loop gates.
- Best for: Regulated enterprise workflows requiring deterministic control and fault recovery.

OPENAI AGENTS SDK / SWARM (The Lightweight Handoff Champion)
- Core Model: Explicit function-based Handoffs passing conversational control.
- Key Capabilities: Minimal boilerplate, native OpenAI model optimization.
- Best for: Customer support triage, multi-agent conversational routing, rapid MVPs.

MICROSOFT AGENT FRAMEWORK (The Enterprise Event-Driven Actor Engine)
- Core Model: Asynchronous Actor Message Passing (Merging AutoGen & Semantic Kernel).
- Key Capabilities: Deep Azure OpenAI integration, multi-modal streaming.
- Best for: Enterprise .NET, Python, and C# cloud architectures.

+-----------------------------------------------------------------------------------------+
|                  The 3 Dominant Multi-Agent Coordination Patterns                       |
+-----------------------------------------------------------------------------------------+

1. HIERARCHICAL SUPERVISOR PATTERN (Top-Down Governance)
              [SUPERVISOR AGENT (Planning & Quality Control)]
                     /              |              \
                    / (Task A)      | (Task B)      \ (Task C)
                   v                v                v
         [RESEARCH AGENT]     [CODER AGENT]    [TESTER AGENT]
                   \                |                /
                    \ (Returns Output & Status)     /
                     v              v              v
              [Supervisor validates -> Emits Final Verified Result]

2. PEER-TO-PEER SWARM HANDOFF (Decentralized Routing)
[User Inbound] ---> [Triage Agent] ---(Handoff)---> [Billing Agent] ---(Handoff)---> [Refund Agent]

3. COLLABORATIVE GROUP CHAT (Round-Robin Consensus)
[Agent A (Idea)] <===> [Agent B (Critic)] <===> [Agent C (Synthesizer)]

# multi_agent_team.py
from typing import Annotated, Literal, TypedDict
import operator
from langchain_openai import ChatOpenAI
from langchain_core.messages import BaseMessage, HumanMessage, SystemMessage
from langgraph.graph import StateGraph, END
from langgraph.checkpoint.memory import MemorySaver

# 1. Define Shared Graph State
class AgentTeamState(TypedDict):
  messages: Annotated[list[BaseMessage], operator.add]
  next_worker: str
  task_summary: str

llm = ChatOpenAI(model="gpt-4o", temperature=0.2)

# 2. Define Worker Agents
def researcher_node(state: AgentTeamState):
  messages = state["messages"]
  system_prompt = SystemMessage(content="You are an expert technical researcher. Search documentation and extract architecture requirements.")
  response = llm.invoke([system_prompt] + messages)
  return {"messages": [HumanMessage(content=response.content, name="Researcher")]}

def coder_node(state: AgentTeamState):
  messages = state["messages"]
  system_prompt = SystemMessage(content="You are a Senior Python/TypeScript software engineer. Write clean, production code with tests.")
  response = llm.invoke([system_prompt] + messages)
  return {"messages": [HumanMessage(content=response.content, name="Coder")]}

def reviewer_node(state: AgentTeamState):
  messages = state["messages"]
  system_prompt = SystemMessage(content="You are a strict Security & QA Lead. Review the code for security vulnerabilities. Output 'APPROVED' or list required fixes.")
  response = llm.invoke([system_prompt] + messages)
  return {"messages": [HumanMessage(content=response.content, name="Reviewer")]}

# 3. Define Supervisor Router Node
def supervisor_node(state: AgentTeamState):
  system_prompt = SystemMessage(
      content="""You are the Engineering Director. Coordinate the team to fulfill the user request.
Given the conversation history, decide which worker should act next:
- 'Researcher': To gather API specs or documentation.
- 'Coder': To write or update code.
- 'Reviewer': To inspect code quality.
- 'FINISH': When the task is 100% complete and approved by the Reviewer.

Output strictly one word: 'Researcher', 'Coder', 'Reviewer', or 'FINISH'."""
  )
  response = llm.invoke([system_prompt] + state["messages"]).content.strip()
  return {"next_worker": response}

# 4. Construct Stateful Directed Cyclic Graph
builder = StateGraph(AgentTeamState)

# Add Nodes
builder.add_node("Supervisor", supervisor_node)
builder.add_node("Researcher", researcher_node)
builder.add_node("Coder", coder_node)
builder.add_node("Reviewer", reviewer_node)

# Add Edges
builder.set_entry_point("Supervisor")

# Conditional Router Edge from Supervisor
builder.add_conditional_edges(
    "Supervisor",
    lambda state: state["next_worker"],
    {
        "Researcher": "Researcher",
        "Coder": "Coder",
        "Reviewer": "Reviewer",
        "FINISH": END,
    },
)

# Workers always report back to Supervisor for validation!
builder.add_edge("Researcher", "Supervisor")
builder.add_edge("Coder", "Supervisor")
builder.add_edge("Reviewer", "Supervisor")

# 5. Compile Graph with Persistent Memory Checkpointer
checkpointer = MemorySaver()
multi_agent_app = builder.compile(checkpointer=checkpointer)

+-----------------------------------------------------------------------------------------+
|                  LangGraph Human-in-the-Loop & Time-Travel Graph                        |
+-----------------------------------------------------------------------------------------+

[State 1: Research Complete] ---> [State 2: Code Drafted] ---> [INTERRUPT BEFORE MERGE]
                                                                        |
                                                                        v (Human Approves on Web Dashboard!)
                                                               [State 3: Merged to Production!]

       +-------------------------------------------------------------+
       |             SWE-Bench Task Success Rate (%)                 |
       +-------------------------------------------------------------+
 Single Monolithic Prompt (GPT-4o)    | ============= [19.4%] (Context Overload)
 Peer-to-Peer Swarm Handoff           | ====================== [32.1%]
 LangGraph Hierarchical Multi-Agent   | ==================================== [48.7%] (2.5x Higher Accuracy!)
                                      +-------------------------------------+
                                      0%     15%     30%     45%     60%