quadrantChart
    title 2026年5月八大Agent框架生态位矩阵
    x-axis "低抽象（接近底层）" --> "高抽象（开箱即用）"
    y-axis "单一语言/平台" --> "多语言/跨平台"
    quadrant-1 "平台型"
    quadrant-2 "生态型"
    quadrant-3 "工具型"
    quadrant-4 "垂直型"
    "LangGraph": [0.35, 0.55]
    "CrewAI": [0.65, 0.35]
    "PydanticAI": [0.30, 0.30]
    "Google ADK": [0.50, 0.85]
    "Claude Agent SDK": [0.40, 0.50]
    "OpenAI Agents SDK": [0.55, 0.40]
    "Microsoft Agent Framework": [0.45, 0.80]
    "Mastra": [0.50, 0.45]
    "Agno": [0.55, 0.35]

from langgraph.graph import StateGraph, END
from typing import TypedDict, Annotated
import operator

class AgentState(TypedDict):
    messages: Annotated[list, operator.add]
    next_agent: str

def router(state: AgentState) -> str:
    """根据对话内容决定下一个Agent"""
    last_msg = state["messages"][-1]
    if "代码" in last_msg:
        return "coder"
    elif "测试" in last_msg:
        return "tester"
    return END

graph = StateGraph(AgentState)
graph.add_node("planner", plan_task)
graph.add_node("coder", write_code)
graph.add_node("tester", run_tests)
graph.add_conditional_edges("planner", router)
graph.add_edge("coder", "tester")
graph.add_edge("tester", END)
app = graph.compile()

from crewai import Agent, Task, Crew, Process

researcher = Agent(
    role="市场研究分析师",
    goal="分析2026年AI Agent市场趋势",
    backstory="你是一位有10年经验的市场分析师，专注于AI领域",
    verbose=True,
    allow_delegation=False
)

writer = Agent(
    role="技术作家",
    goal="将研究结论转化为易读的报告",
    backstory="你擅长将复杂技术概念转化为通俗语言",
    verbose=True,
    allow_delegation=True
)

research_task = Task(
    description="调研2026年AI Agent市场的主要玩家和趋势",
    agent=researcher,
    expected_output="一份包含市场数据和趋势分析的报告"
)

write_task = Task(
    description="基于研究结论撰写面向决策者的摘要报告",
    agent=writer,
    expected_output="一份2000字以内的可发布报告"
)

crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, write_task],
    process=Process.sequential
)

result = crew.kickoff()

from google.adk import Agent, Runner
from google.adk.tools import google_search

research_agent = Agent(
    name="researcher",
    model="gemini-2.5-pro",
    instruction="你是一个研究助手，帮助用户收集和分析信息",
    tools=[google_search]
)

code_agent = Agent(
    name="coder", 
    model="gemini-2.5-pro",
    instruction="你是一个编程助手，帮助用户编写和调试代码",
    tools=[]  # 可接入自定义工具
)

# A2A协议支持跨Agent通信
runner = Runner(agent=research_agent)
result = await runner.run("分析2026年AI Agent框架市场格局")

from claude_agent_sdk import Agent, Tool
from claude_agent_sdk.tools import bash, file_edit

# 定义自定义工具
@tool
def search_database(query: str) -> str:
    """搜索内部数据库"""
    # 实际数据库查询逻辑
    return f"查询结果: {query}..."

agent = Agent(
    name="data_analyst",
    tools=[bash, file_edit, search_database],
    hooks={
        "pre_tool_use": lambda tool, args: validate_permission(tool),
        "post_response": lambda resp: log_interaction(resp)
    }
)

# 支持子Agent委派
result = await agent.run(
    "分析数据库中的用户行为数据，生成报告",
    subagents=[report_writer_agent, chart_generator_agent]
)

from microsoft.agent_framework import Agent, AgentGroup
from microsoft.agent_framework.orchestration import Sequential, GroupChat

analyst = Agent(
    name="analyst",
    instructions="分析用户需求并制定执行计划"
)

developer = Agent(
    name="developer",
    instructions="根据计划编写代码"
)

reviewer = Agent(
    name="reviewer",
    instructions="审查代码质量并提出改进建议"
)

# 群聊模式：Agent之间自由对话
group = AgentGroup(
    agents=[analyst, developer, reviewer],
    orchestration=GroupChat(max_turns=10),
    termination_condition=lambda msgs: "APPROVED" in msgs[-1]
)

result = await group.invoke("构建一个Web爬虫Agent")

from pydantic_ai import Agent, RunContext
from pydantic import BaseModel
from dataclasses import dataclass

class SearchResult(BaseModel):
    title: str
    url: str
    relevance_score: float

@dataclass
class Deps:
    db_client: DatabaseClient
    api_key: str

search_agent = Agent(
    'openai:gpt-4o',
    deps_type=Deps,
    result_type=list[SearchResult],
    system_prompt="你是一个搜索助手，帮助用户找到相关信息"
)

@search_agent.tool
async def search_web(ctx: RunContext[Deps], query: str) -> str:
    """搜索互联网"""
    results = await web_search(query, api_key=ctx.deps.api_key)
    return format_results(results)

@search_agent.tool
async def search_database(ctx: RunContext[Deps], query: str) -> str:
    """搜索内部数据库"""
    results = await ctx.deps.db_client.search(query)
    return format_results(results)

# 类型安全的调用
result = await search_agent.run(
    "查找关于AI Agent框架的最新研究",
    deps=Deps(db_client=my_db, api_key="sk-...")
)
# result.data 是 list[SearchResult] 类型
for item in result.data:
    print(f"{item.title} (相关度: {item.relevance_score})")

import { Agent, Tool, Workflow } from '@mastra/core';
import { z } from 'zod';

const researchTool: Tool = {
  name: 'web_search',
  description: '搜索互联网获取最新信息',
  parameters: z.object({
    query: z.string().describe('搜索查询'),
    max_results: z.number().optional().default(5)
  }),
  execute: async ({ query, max_results }) => {
    const results = await searchEngine.search(query, { limit: max_results });
    return results;
  }
};

const analyst = new Agent({
  name: 'market_analyst',
  instructions: '你是一个市场分析专家，帮助分析行业趋势',
  model: 'gpt-4o',
  tools: [researchTool]
});

// 使用工作流引擎编排多步骤任务
const analysisWorkflow = new Workflow({
  name: 'market_analysis',
  steps: [
    { name: 'research', agent: analyst },
    { name: 'analyze', agent: analyst, retry: { attempts: 3 } },
    { name: 'report', agent: reportWriter }
  ]
});

const result = await analysisWorkflow.run({
  input: '分析2026年AI Agent市场格局'
});

from agno.agent import Agent
from agno.models.openai import OpenAIChat
from agno.tools.duckduckgo import DuckDuckGoTools
from agno.knowledge.url import UrlKnowledge

# 极简Agent定义
agent = Agent(
    name="Research Agent",
    model=OpenAIChat(id="gpt-4o"),
    tools=[DuckDuckGoTools()],
    knowledge=UrlKnowledge(urls=["https://example.com/docs"]),
    show_tool_calls=True,
    markdown=True
)

# 多模态支持
multimodal_agent = Agent(
    name="Vision Agent",
    model=OpenAIChat(id="gpt-4o"),
    tools=[],
    # 直接传入图像URL
)

response = agent.run("分析当前AI Agent市场的主要趋势")
print(response.content)

flowchart TD
    subgraph "协议生态"
        MCP["MCP<br/>Model Context Protocol<br/>Anthropic主导<br/>97M+ npm下载"]
        A2A["A2A<br/>Agent-to-Agent Protocol<br/>Google主导<br/>50+合作伙伴"]
        ACP["ACP<br/>Agent Communication Protocol<br/>IBM主导<br/>企业级标准"]
    end

    subgraph "框架对齐"
        CAS["Claude Agent SDK<br/>MCP原生"]
        ADK["Google ADK<br/>A2A原生"]
        LG["LangGraph<br/>MCP集成"]
        SK["Microsoft AF<br/>ACP倾向"]
        CA["CrewAI<br/>协议中立"]
        PA["PydanticAI<br/>协议中立"]
        MA["Mastra<br/>MCP社区"]
        AG["Agno<br/>协议中立"]
    end

    CAS --> MCP
    ADK --> A2A
    LG -.-> MCP
    SK -.-> ACP
    MA -.-> MCP

    MCP <-->|"互操作"| A2A
    A2A <-->|"互操作"| ACP
    MCP <-->|"互操作"| ACP

graph LR
    subgraph "低迁移成本"
        AG["Agno"] --> PA["PydanticAI"]
        PA --> CA["CrewAI"]
    end

    subgraph "中等迁移成本"
        CA --> LG["LangGraph"]
        MA["Mastra"] --> LG
    end

    subgraph "高迁移成本（单向门）"
        CAS["Claude Agent SDK"] -->|"模型绑定"| X1["难以迁出"]
        ADK["Google ADK"] -->|"A2A绑定"| X2["协议锁死"]
        SK["Microsoft AF"] -->|".NET绑定"| X3["语言锁定"]
    end

    style X1 fill:#ff6b6b
    style X2 fill:#ff6b6b
    style X3 fill:#ff6b6b

flowchart TD
    START["选择Agent框架"] --> Q1{"你的主力语言？"}

    Q1 -->|"TypeScript"| TS_PATH["Mastra（首选）<br/>LangGraph.js（复杂场景）"]
    Q1 -->|".NET"| DOTNET["Microsoft Agent Framework<br/>（唯一成熟选择）"]
    Q1 -->|"Java"| JAVA["Google ADK（唯一成熟选择）"]
    Q1 -->|"Go"| GO["Google ADK（唯一成熟选择）"]
    Q1 -->|"Python"| Q2{"项目复杂度？"}

    Q2 -->|"简单原型"| Q3{"是否需要多Agent？"}
    Q3 -->|"是"| CREWAI_SIMPLE["CrewAI"]
    Q3 -->|"否"| AGNO_SIMPLE["Agno（最快上手）<br/>或 PydanticAI（类型安全）"]

    Q2 -->|"中等复杂度"| Q4{"你的团队重视什么？"}
    Q4 -->|"类型安全/可测试性"| PYDANTIC["PydanticAI"]
    Q4 -->|"快速多Agent"| CREWAI["CrewAI"]
    Q4 -->|"Anthropic生态"| CLAUDE_SDK["Claude Agent SDK"]
    Q4 -->|"OpenAI生态"| OPENAI_SDK["OpenAI Agents SDK"]

    Q2 -->|"高度复杂"| Q5{"是否需要企业级持久化？"}
    Q5 -->|"是"| LANGGRAPH["LangGraph（状态图+checkpoint）"]
    Q5 -->|"否"| Q6{"是否跨组织协作？"}
    Q6 -->|"是"| GOOGLE_ADK["Google ADK（A2A协议）"]
    Q6 -->|"否"| LANGGRAPH2["LangGraph（最灵活）"]

    style TS_PATH fill:#4ecdc4
    style DOTNET fill:#4ecdc4
    style JAVA fill:#4ecdc4
    style GO fill:#4ecdc4
    style LANGGRAPH fill:#ffe66d
    style PYDANTIC fill:#ffe66d