Agent框架决策树：八栈项目匹配实测

graph TB
    subgraph "厂牌SDK层 (Vendor-Native)"
        OAI["OpenAI Agents SDK<br/>模型锁定·深度集成"]
        GADK["Google ADK 2.0<br/>A2A协议·Gemini原生"]
        CLAUDE["Claude Agent SDK<br/>MCP原生·托管双轨"]
    end

    subgraph "企业统一栈 (Enterprise Unified)"
        MAF["Microsoft Agent Framework<br/>AutoGen+SK合并·.NET/Python"]
    end

    subgraph "模型无关框架 (Model-Agnostic)"
        LG["LangGraph<br/>状态图编排·复杂工作流"]
        CREW["CrewAI<br/>角色协作·多Agent"]
        PAI["PydanticAI<br/>类型安全·轻量"]
        AGNO["Agno<br/>高性能·全栈运行时"]
    end

    OAI --> LG
    GADK --> LG
    CLAUDE --> LG
    MAF -.-> LG
    MAF -.-> CREW

    style OAI fill:#10a37f,color:#fff
    style GADK fill:#4285f4,color:#fff
    style CLAUDE fill:#d97706,color:#fff
    style MAF fill:#00bcf2,color:#fff
    style LG fill:#1c1917,color:#fff
    style CREW fill:#7c3aed,color:#fff
    style PAI fill:#e11d48,color:#fff
    style AGNO fill:#f59e0b,color:#1c1917

flowchart TD
    START["开始选型"] --> Q1{"是否只使用单一<br/>模型厂商？"}

    Q1 -->|是| Q2{"使用哪家模型？"}
    Q2 -->|OpenAI| OAI_R["✅ OpenAI Agents SDK"]
    Q2 -->|Google Gemini| GADK_R["✅ Google ADK 2.0"]
    Q2 -->|Anthropic Claude| CLAUDE_R["✅ Claude Agent SDK"]

    Q1 -->|否·需要模型自由| Q3{"是否.NET技术栈<br/>或微软生态？"}
    Q3 -->|是| MAF_R["✅ Microsoft Agent Framework"]
    Q3 -->|否·Python| Q4{"项目复杂度？"}

    Q4 -->|简单单Agent| Q5{"是否需要类型安全<br/>和生产保障？"}
    Q5 -->|是| PAI_R["✅ PydanticAI"]
    Q5 -->|否·追求速度| AGNO_R["✅ Agno"]

    Q4 -->|复杂多步工作流| LG_R["✅ LangGraph"]
    Q4 -->|多Agent角色协作| Q6{"吞吐量需求？"}
    Q6 -->|高·每秒百级| AGNO_R2["✅ Agno"]
    Q6 -->|中低·注重可调试| CREW_R["✅ CrewAI"]

    style OAI_R fill:#10a37f,color:#fff
    style GADK_R fill:#4285f4,color:#fff
    style CLAUDE_R fill:#d97706,color:#fff
    style MAF_R fill:#00bcf2,color:#fff
    style LG_R fill:#1c1917,color:#fff
    style CREW_R fill:#7c3aed,color:#fff
    style PAI_R fill:#e11d48,color:#fff
    style AGNO_R fill:#f59e0b,color:#1c1917
    style AGNO_R2 fill:#f59e0b,color:#1c1917

from agents import Agent, Runner, handoff, GuardrailFunctionOutput
from agents import input_guardrail

# 定义专家Agent
triage_agent = Agent(
    name="Triage Agent",
    instructions="判断用户意图并转交",
    model="o3",
)

billing_agent = Agent(
    name="Billing Expert",
    instructions="处理账单相关问题",
    tools=[lookup_invoice, process_refund],
)

# Handoff原生转交
triage_agent.handoffs = [handoff(billing_agent)]

# 输入Guardrail防止注入
@input_guardrail
async def check_injection(ctx, agent, input):
    result = await Runner.run(injection_detector, input)
    return GuardrailFunctionOutput(
        output_info=result.final_output,
        tripwire_triggered=result.final_output.is_injection
    )

triage_agent.input_guardrails = [check_injection]
result = await Runner.run(triage_agent, "我要退款")

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

# ADK 2.0 图工作流
research_agent = Agent(
    name="Researcher",
    model="gemini-2.5-pro",
    instruction="深度研究给定主题",
    tools=[google_search],
)

writer_agent = Agent(
    name="Writer", 
    model="gemini-2.5-pro",
    instruction="基于研究结果撰写报告",
)

# 图编排
graph = WorkflowGraph()
graph.add_node("research", research_agent)
graph.add_node("write", writer_agent)
graph.add_edge("research", "write")
graph.set_entry("research")

runner = Runner(app_name="research_pipeline")
result = await runner.run_graph(graph, "分析2026年AI Agent趋势")

from claude_agent_sdk import Agent, MCPServer, ManagedAgent

# MCP原生工具定义
filesystem_server = MCPServer(
    command="npx",
    args=["-y", "@anthropic/mcp-filesystem", "/data"],
)

# 自托管Agent
agent = Agent(
    model="claude-sonnet-4-6",
    instructions="分析数据文件并生成报告",
    mcp_servers=[filesystem_server],
    tools=[generate_chart, send_email],
)

# 或者：托管模式——Anthropic运行一切
managed = ManagedAgent(
    model="claude-sonnet-4-6",
    instructions="分析数据文件并生成报告",
    tools=[generate_chart],
    sandbox="self-hosted",  # 2026年5月新增自托管沙箱
)
result = await managed.run("分析sales_2026.csv")

// C# 示例 —— MAF统一接口
using Microsoft.AgentFramework;

var planner = new AgentBuilder()
    .WithModel("gpt-4o")
    .WithInstructions("你是项目规划师")
    .WithPlugin(new ProjectPlugin())  // Semantic Kernel插件
    .Build();

var coder = new AgentBuilder()
    .WithModel("o3")
    .WithInstructions("你是代码实现者")
    .WithPlugin(new CodePlugin())
    .Build();

// AutoGen风格的多Agent对话
var groupChat = new AgentGroupChat(planner, coder)
{
    MaxTurns = 10,
    SelectionStrategy = new RoundRobinStrategy(),
};

await foreach (var message in groupChat.InvokeAsync("实现一个Web服务器"))
{
    Console.WriteLine($"{message.Author}: {message.Content}");
}

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

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

def router(state: AgentState) -> str:
    if state["retry_count"] > 3:
        return "escalate"
    return state["next_action"]

# 构建状态图
graph = StateGraph(AgentState)
graph.add_node("think", think_node)
graph.add_node("act", act_node)
graph.add_node("evaluate", evaluate_node)
graph.add_node("escalate", escalate_to_human)

graph.add_conditional_edges("evaluate", router, {
    "retry": "think",
    "done": END,
    "escalate": "escalate",
})

# 持久化检查点
checkpointer = MemorySaver()  # 生产环境用PostgresSaver
app = graph.compile(
    checkpointer=checkpointer,
    interrupt_before=["escalate"],  # 人工审批断点
)

# 执行——可中断、可恢复
config = {"configurable": {"thread_id": "session-123"}}
result = await app.ainvoke({"messages": ["处理订单"]}, config)

from crewai import Agent, Task, Crew, Process

researcher = Agent(
    role="Senior Research Analyst",
    goal="Discover and analyze emerging AI trends",
    backstory="你是一位有15年经验的技术分析师...",
    tools=[search_tool, scrape_tool],
    llm="gpt-4o",
)

writer = Agent(
    role="Technical Writer",
    goal="将研究发现转化为引人入胜的文章",
    backstory="你是顶级科技媒体的专栏作家...",
    llm="claude-sonnet-4-6",
)

research_task = Task(
    description="研究2026年AI Agent框架趋势",
    agent=researcher,
    expected_output="包含10个发现的详细报告",
)

write_task = Task(
    description="基于研究写一篇3000字分析文章",
    agent=writer,
    expected_output="Markdown格式的完整文章",
)

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

result = crew.kickoff()

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

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

class ResearchReport(BaseModel):
    summary: str
    findings: list[SearchResult]
    confidence: float

research_agent = Agent(
    model="openai:gpt-4o",  # 声明式模型切换
    result_type=ResearchReport,  # 强类型输出
    system_prompt="你是一位严谨的研究分析师",
)

@research_agent.tool
async def search(ctx, query: str) -> list[SearchResult]:
    """搜索工具——返回类型自动校验"""
    results = await search_api(query)
    return [SearchResult(**r) for r in results]

# 结果自动校验和解析
result = await research_agent.run("分析AI Agent框架市场")
report: ResearchReport = result.data  # 类型安全
print(f"置信度: {report.confidence}")

from agno.agent import Agent
from agno.models.openai import OpenAIChat
from agno.tools.duckduckgo import DuckDuckGoTools
from agno.knowledge.text import Doc

# 极简Agent定义——5ms实例化
agent = Agent(
    model=OpenAIChat(id="gpt-4o"),
    tools=[DuckDuckGoTools()],
    knowledge=[Doc(content="公司内部知识库...")],
    instructions=["搜索最新信息", "引用来源"],
    show_tool_calls=True,
    markdown=True,
)

# 同步/异步执行
agent.print_response("2026年最好的Agent框架是什么？")

# 生产部署：Agent Server
# agno serve agent.py --port 8000 --workers 4
# 自动获得REST API、WebSocket、SSE端点