graph TB
    subgraph "ReAct循环模型"
        R1[用户输入] --> R2[LLM推理]
        R2 --> R3{需要工具?}
        R3 -->|是| R4[调用工具]
        R4 --> R2
        R3 -->|否| R5[输出结果]
    end

    subgraph "图工作流模型"
        G1[起始节点] --> G2[预处理]
        G2 --> G3{条件分支}
        G3 -->|路径A| G4[Agent A]
        G3 -->|路径B| G5[Agent B]
        G4 --> G6[聚合]
        G5 --> G6
        G6 --> G7[输出]
    end

    subgraph "协议原生模型"
        P1[MCP Client] -->|工具请求| P2[MCP Server]
        P3[A2A Agent A] -->|任务委派| P4[A2A Agent B]
        P4 -->|结果返回| P3
        P2 -->|工具结果| P1
    end

    style R2 fill:#ff6b6b,color:#fff
    style G3 fill:#4ecdc4,color:#fff
    style P1 fill:#45b7d1,color:#fff
    style P3 fill:#45b7d1,color:#fff

from agents import Agent, Runner, function_tool

@function_tool
def get_weather(city: str) -> str:
    return f"{city}今天晴，气温28°C"

agent = Agent(
    name="WeatherBot",
    instructions="你是天气助手，回答天气相关问题",
    tools=[get_weather],
)

# Runner.run() 内部实现（简化版）:
# while True:
#     response = await llm.call(messages, tools)
#     if not response.tool_calls:
#         return response.content  # 终止循环
#     for tool_call in response.tool_calls:
#         result = await execute_tool(tool_call)
#         messages.append(tool_result)

result = await Runner.run(agent, "北京天气怎么样？")

from agents import Agent, Runner

triage_agent = Agent(name="Triage")
billing_agent = Agent(name="Billing", handoff_description="处理账单问题")

triage_agent.handoffs = [billing_agent]

# Handoff本质上是特殊的tool_call:
# LLM产出 {"type": "handoff", "agent": "Billing"}
# Runner将上下文转移到billing_agent继续循环

from google.adk import Agent, Workflow, WorkflowBuilder

# ADK 1.x 风格（层次化树）
root_agent = Agent(
    name="root",
    sub_agents=[research_agent, writer_agent]  # 树形结构
)

# ADK 2.0 风格（图工作流）
workflow = WorkflowBuilder() \
    .add_node("input", input_handler) \
    .add_node("research", research_agent) \
    .add_node("writer", writer_agent) \
    .add_node("review", review_agent) \
    .add_edge("input", "research") \
    .add_conditional_edge("research", "router", {
        "write": "writer",
        "retry": "research"  # 循环边！
    }) \
    .add_edge("writer", "review") \
    .add_conditional_edge("review", "check", {
        "approve": END,
        "revise": "writer"   # 回退边！
    }) \
    .build()

result = await workflow.run("写一篇关于量子计算的文章")

// 引擎1：AutoGen风格的对话式Agent（适合探索性任务）
var agent1 = new ChatAgent("Researcher", "研究相关主题");
var agent2 = new ChatAgent("Writer", "撰写文章");
var group = new AgentGroup(agent1, agent2);
await group.RunAsync("研究并撰写AI趋势报告");

// 引擎2：Semantic Kernel风格的规划器（适合确定性工作流）
var kernel = Kernel.CreateBuilder()
    .AddAzureOpenAIChatCompletion(...)
    .Build();
var planner = new HandlebarsPlanner();
var plan = await planner.CreatePlan("处理客户退款请求");
await plan.InvokeAsync();

// Workflow可以混合使用两种引擎的Agent
var workflow = new AgentWorkflow()
    .AddStep("intake", kernelAgent)       // SK风格的确定性Agent
    .AddStep("research", autoGenAgent)    // AutoGen风格的探索性Agent
    .AddStep("decision", kernelAgent)     // 回到确定性决策
    .AddStep("notify", autoGenAgent);     // 灵活的通知Agent

from langgraph.graph import StateGraph, END
from typing import TypedDict, Annotated
from langgraph.graph.message import add_messages

class AgentState(TypedDict):
    messages: Annotated[list, add_messages]  # Reducer模式
    next_agent: str
    retry_count: int

def researcher(state: AgentState):
    # 节点函数：接收状态，返回状态更新
    result = llm.invoke(state["messages"])
    return {"messages": [result], "next_agent": "writer"}

def should_continue(state: AgentState):
    if state["retry_count"] > 3:
        return "human_review"  # 超过重试次数，交给人类
    return "researcher"

graph = StateGraph(AgentState)
graph.add_node("researcher", researcher)
graph.add_node("writer", writer)
graph.add_node("human_review", human_review)
graph.add_conditional_edges("researcher", should_continue)
graph.add_edge("writer", END)

app = graph.compile(checkpointer=SqliteSaver("agent.db"))

# 保存检查点后，可以从任意历史状态恢复
config = {"configurable": {"thread_id": "session-1"}}
result = await app.ainvoke(input, config)

# 时间旅行：回放历史状态
history = [state async for state in app.aget_state_history(config)]
# 选择某个历史状态重新执行
await app.aupdate_state(history[3].config, {"retry_count": 0})

from claude_agent import Agent, MCPServer

# Agent Loop通过MCP获取工具列表
agent = Agent(
    model="claude-sonnet-4-20250514",
    mcp_servers=[
        MCPServer("filesystem", command="mcp-server-filesystem /data"),
        MCPServer("postgres", command="mcp-server-postgres postgresql://..."),
    ]
)

# Runner Loop（简化版）:
# 1. 通过MCP discover_tools() 获取所有可用工具
# 2. 调用LLM，传入工具schema
# 3. 如果LLM产出tool_use，通过MCP call_tool() 执行
# 4. 结果通过MCP返回，注入上下文继续循环

result = await agent.run("查询订单#12345的物流状态")

import { Agent, Tool, Workflow } from "@mastra/core";

const weatherTool: Tool = {
  name: "get_weather",
  description: "获取城市天气",
  parameters: {
    type: "object",
    properties: {
      city: { type: "string" }
    }
  },
  execute: async ({ city }) => {
    const response = await fetch(`/api/weather?city=${city}`);
    return response.json();
  }
};

// Mastra的Agent与Workflow是正交概念
const agent = new Agent({
  name: "WeatherAgent",
  instructions: "你是天气助手",
  tools: [weatherTool],
});

// Workflow是独立的图结构
const workflow = new Workflow()
  .step("fetch", agent)
  .step("format", formatter)
  .after("fetch").run("format");

import { evaluate } from "@mastra/evals";

const result = await evaluate({
  agent,
  input: "北京明天会下雨吗？",
  scorers: [accuracy, toolUsageCorrectness, latency],
  dataset: testDataset,  // 自动生成测试集
});

graph LR
    subgraph "Agent Loop实现"
        A1["OpenAI: while循环<br/>+ tool_call解析"]
        A2["CrewAI: Process引擎<br/>Sequential/Hierarchical"]
        A3["ADK 2.0: Graph遍历<br/>+ 条件边路由"]
        A4["LangGraph: StateGraph<br/>+ Reducer归约"]
        A5["Claude: MCP协议循环<br/>+ 工具发现"]
        A6["Mastra: Agent × Workflow<br/>正交组合"]
    end

    subgraph "状态存储"
        B1["messages列表<br/>(内存)"]
        B2["AgentContext<br/>(内存)"]
        B3["Checkpoint Store<br/>(Cloud Storage)"]
        B4["SqliteSaver<br/>(本地/云)"]
        B5["MCP Server<br/>(分布式)"]
        B6["Workflow State<br/>(内置持久化)"]
    end

    subgraph "工具注册"
        C1["@function_tool装饰器"]
        C2["BaseTool类继承"]
        C3["ADK Tool函数"]
        C4["tool()函数包装"]
        C5["MCP Server自动发现"]
        C6["Tool接口实现"]
    end

    A1 --> B1
    A2 --> B2
    A3 --> B3
    A4 --> B4
    A5 --> B5
    A6 --> B6

    style A3 fill:#4285f4,color:#fff
    style A4 fill:#1a1a2e,color:#fff
    style A5 fill:#d97706,color:#fff
    style A6 fill:#06b6d4,color:#fff

quadrantChart
    title Agent Framework Selection Matrix
    x-axis Low Complexity --> High Complexity
    y-axis Prototype --> Production
    quadrant-1 "Enterprise Production"
    quadrant-2 "Heavy Duty Production"
    quadrant-3 "Quick Prototyping"
    quadrant-4 "Production Simple"
    "OpenAI Agents SDK": [0.25, 0.55]
    "CrewAI": [0.35, 0.40]
    "ADK 2.0": [0.80, 0.90]
    "LangGraph": [0.70, 0.85]
    "Claude Agent SDK": [0.55, 0.60]
    "Mastra": [0.65, 0.75]