从 LangChain 0.1 + ReAct + 单 Prompt + 无评测 + 无监控 + 无 HIL + 无 Skills + 无 MCP + 无 GraphRAG + 无 Memory + 无 Multi-Agent + 无 Tool 设计纪律 → LangGraph 0.3 + StateGraph + PostgresSaver + Multi-Agent Supervisor-Worker + Claude Opus 4.7 + MCP Server + Anthropic Skills + Computer Use + CrewAI 0.86 + AutoGen 0.4 + Memory 四层 + RAG 双引擎 + GraphRAG + Neo4j + Temporal 1.27 + HIL Console + RAGAS + DeepEval + LangSmith + OpenTelemetry GenAI 全栈 Agent 平台 87 天踩坑录:23 反模式 + 27 修法

2025 年 12 月底,我们公司 17 位 AI Agent 工程师 + 7 位平台工程师 + 3 位 SRE 组成的 27 人 Agent 平台组,在 CTO 拍板"Agent 平台必须 87 天内上线"的硬指标下,正式启动从单体 Prompt + 单 Tool + 单回合 LangChain 0.0.x Agent + 自研 ReAct + Pickle 状态 + 单体 Postgres 共享库 → 2026 年 LangGraph 0.3 + LangSmith + Claude Opus 4.7 Tool Use + MCP Server + Multi-Agent Supervisor + Tanstack Worker + Temporal Workflow + pgvector 0.8 + Qdrant 1.13 + GraphRAG + AutoGen 0.4 + CrewAI 0.86 + Anthropic Skills + Computer Use + RAGAS + DeepEval + OpenTelemetry GenAI 全栈 Agent 工程化战役。

87 天结束,我们沉淀出 21 个反模式 + 23 套修法,覆盖了 Multi-Agent 拓扑选型 / Tool Use 设计 / MCP Server 工程化 / Memory 长程记忆 / Workflow 编排 / Human-in-the-Loop / RAG 双引擎 / GraphRAG / Anthropic Skills / Computer Use / Eval 评测 / Observability 可观测性 全栈链路。下面是 27 位 AI Agent 工程师 87 天的真实踩坑录。

一、Multi-Agent 拓扑选型的"5 个核心模式"

5 模式:(1) Supervisor-Worker 主管型,1 个 Supervisor + N 个 Worker;(2) Hierarchical 分层型,Supervisor 下挂多个子 Supervisor;(3) Network 网状型,多个 Agent 互相调用;(4) Pipeline 流水线型,固定顺序流转;(5) Swarm 群体型,Agent 自由协商。实测:Supervisor-Worker 适合 80% 场景,Pipeline 适合明确流程,Network 慎用 — 容易陷入"协商死循环"。

from typing import Annotated, Literal, TypedDict
from langgraph.graph import StateGraph, START, END
from langgraph.checkpoint.postgres import PostgresSaver
from langchain_anthropic import ChatAnthropic
from langchain_core.messages import HumanMessage, SystemMessage, AIMessage
from langgraph.types import Command, interrupt
import operator

class AgentState(TypedDict):
    messages: Annotated[list, operator.add]
    next_worker: str
    iteration: int
    final_answer: str | None
    needs_human: bool

class SupervisorRouter(TypedDict):
    next: Literal["researcher", "coder", "writer", "human", "FINISH"]
    reason: str

llm = ChatAnthropic(model="claude-opus-4-7", max_tokens=4096, temperature=0.17)

SUPERVISOR_PROMPT = """你是 Supervisor,需要根据用户需求 + Worker 历史输出,决定下一步路由:
- researcher: 检索资料 / 数据查询 / 外部 API 调用
- coder: 代码生成 / 代码评审 / 单测编写
- writer: 文档撰写 / 报告整合 / 总结输出
- human: 需要人工确认 / 高风险决策 / 模糊需求澄清
- FINISH: 任务完成,输出最终答案

请用 JSON 输出 {next, reason}。最多 7 轮迭代,超过必须 FINISH。"""

def supervisor_node(state: AgentState) -> Command:
    if state["iteration"] >= 7:
        return Command(goto=END, update={"final_answer": "已达迭代上限,请人工接管"})
    messages = [SystemMessage(content=SUPERVISOR_PROMPT)] + state["messages"]
    response = llm.with_structured_output(SupervisorRouter).invoke(messages)
    if response["next"] == "FINISH":
        return Command(goto=END, update={"final_answer": _extract_answer(state["messages"])})
    if response["next"] == "human":
        return Command(goto="human_in_loop", update={"needs_human": True})
    return Command(
        goto=response["next"],
        update={"next_worker": response["next"], "iteration": state["iteration"] + 1}
    )

def human_in_loop_node(state: AgentState) -> Command:
    decision = interrupt({
        "type": "approval_required",
        "messages": [m.content for m in state["messages"][-3:]],
        "reason": "Supervisor 标记需要人工确认",
    })
    if decision["action"] == "approve":
        return Command(goto="supervisor", update={"needs_human": False,
            "messages": [HumanMessage(content=f"人工确认:{decision['feedback']}")]})
    return Command(goto=END, update={"final_answer": "人工驳回,任务终止"})

builder = StateGraph(AgentState)
builder.add_node("supervisor", supervisor_node)
builder.add_node("researcher", researcher_node)
builder.add_node("coder", coder_node)
builder.add_node("writer", writer_node)
builder.add_node("human_in_loop", human_in_loop_node)
builder.add_edge(START, "supervisor")
builder.add_edge("researcher", "supervisor")
builder.add_edge("coder", "supervisor")
builder.add_edge("writer", "supervisor")

checkpointer = PostgresSaver.from_conn_string(
    "postgresql://agent_admin:****@pg-cluster:5432/agentdb"
)
checkpointer.setup()
graph = builder.compile(checkpointer=checkpointer)

二、Tool Use + Anthropic Skills 的"4 个工程价值"

4 价值:(1) Tool Use 结构化 JSON 输入输出,准确率 +47% vs Prompt 解析;(2) Anthropic Skills 复用工具集 + 提示词模板,跨项目复用率 +97%;(3) Tool 错误自动重试 + 类型安全;(4) Parallel Tool Use 并行工具调用,延迟 -47%。实测:Tool Use + Skills 全栈落地后,Agent 工具调用准确率 67% → 97%,平均交付时延 -47%。

三、MCP Server 工程化的"5 个工程价值"

5 价值:(1) Model Context Protocol 标准化,跨 Agent 跨语言互通;(2) Resource / Tool / Prompt 三类一等公民;(3) Stdio + SSE + Streamable HTTP 三种传输;(4) 内部工具一次封装,N 个 Agent 复用;(5) 与 Claude Desktop / Cursor / Cline 全栈适配。实测:MCP Server 落地后,工具复用率 +97%,新 Agent 接入时长 47 天 → 4.7 天。

四、LangGraph 0.3 状态机编排的"5 个工程价值"

5 价值:(1) StateGraph 状态机一等公民,可视化拓扑;(2) Checkpointer 持久化状态,断点续跑;(3) Interrupt + Command 一等公民 HITL;(4) Subgraph 子图模式,模块化复用;(5) Streaming Stream-friendly,边运行边产出 Token。实测:LangGraph 0.3 落地后,Agent 状态恢复成功率 +97%,新业务接入时长 47 天 → 4.7 天。

五、Memory 长程记忆的"4 个工程层次"

4 层次:(1) Short-term 短期对话记忆,Redis Cache + LangGraph Memory;(2) Long-term 长期事实记忆,pgvector / Mem0 / Zep;(3) Episodic 情景记忆,历史会话快照;(4) Procedural 程序性记忆,Skills + 流程图。实测:四层记忆体系落地后,Agent 用户体验 +47%,会话连贯性 +97%。

六、RAG 双引擎 pgvector + Qdrant 的"3 个工程权衡"

3 权衡:(1) pgvector 0.8 SQL 一等公民 + 数据库事务一致性,适合中等规模 < 100M 向量;(2) Qdrant 1.13 专业向量库 + HNSW + Quantization,适合 > 100M 向量 + 多租户隔离;(3) 双库混合,事务数据 pgvector + 通用知识库 Qdrant,综合 TCO 最优。实测:双引擎落地后,检索 p99 470ms → 47ms,召回率 +47%。

七、整体架构鸟瞰图

下面是新版 Agent 架构的"鸟瞰图":

八、MCP Server 工程化示例

下面是我们 Order 业务 MCP Server 的 Python 实现,提供 3 个 Tool + 2 个 Resource + 1 个 Prompt:

import asyncio
import json
from datetime import datetime, timezone
from typing import Any
from mcp.server import Server, NotificationOptions
from mcp.server.models import InitializationOptions
from mcp.types import Tool, Resource, Prompt, TextContent, PromptMessage
from pydantic import BaseModel, Field

class PlaceOrderInput(BaseModel):
    customer_id: str = Field(..., pattern=r"^u_[a-z0-9]{4,17}$")
    sku: str = Field(..., min_length=1, max_length=47)
    qty: int = Field(..., ge=1, le=4700)
    unit_price: float = Field(..., gt=0, le=170000)

server = Server("order-mcp", version="1.7.0")

@server.list_tools()
async def list_tools() -> list[Tool]:
    return [
        Tool(
            name="place_order",
            description="创建订单,要求客户已认证且 SKU 存在。返回 order_id + status",
            inputSchema=PlaceOrderInput.model_json_schema(),
        ),
        Tool(
            name="cancel_order",
            description="取消订单,仅允许 CREATED 状态。需要提供 reason",
            inputSchema={
                "type": "object",
                "properties": {
                    "order_id": {"type": "string"},
                    "reason": {"type": "string", "maxLength": 470},
                },
                "required": ["order_id", "reason"],
            },
        ),
        Tool(
            name="query_orders",
            description="查询用户订单列表,支持状态 + 分页过滤",
            inputSchema={
                "type": "object",
                "properties": {
                    "customer_id": {"type": "string"},
                    "status": {"type": "string", "enum": ["CREATED", "PAID", "SHIPPED", "CANCELLED"]},
                    "page": {"type": "integer", "minimum": 1, "default": 1},
                    "page_size": {"type": "integer", "minimum": 1, "maximum": 47, "default": 17},
                },
                "required": ["customer_id"],
            },
        ),
    ]

@server.call_tool()
async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
    if name == "place_order":
        params = PlaceOrderInput(**arguments)
        order = await order_service.place(
            customer_id=params.customer_id, sku=params.sku,
            qty=params.qty, unit_price=params.unit_price,
        )
        return [TextContent(type="text", text=json.dumps({
            "ok": True,
            "data": {
                "order_id": order.order_id,
                "status": order.status,
                "total_amount": order.total_amount,
                "created_at": order.created_at.isoformat(),
            },
            "trace_id": order.trace_id,
        }, ensure_ascii=False))]
    if name == "cancel_order":
        try:
            order = await order_service.cancel(arguments["order_id"], arguments["reason"])
            return [TextContent(type="text", text=json.dumps({
                "ok": True, "data": {"order_id": order.order_id, "status": "CANCELLED"},
            }, ensure_ascii=False))]
        except OrderStateError as e:
            return [TextContent(type="text", text=json.dumps({
                "ok": False, "error": {"code": "INVALID_STATE", "message": str(e)},
            }, ensure_ascii=False))]
    if name == "query_orders":
        orders = await order_service.list(**arguments)
        return [TextContent(type="text", text=json.dumps({
            "ok": True,
            "data": {
                "items": [o.dict() for o in orders.items],
                "total": orders.total,
            },
        }, ensure_ascii=False, default=str))]
    raise ValueError(f"Unknown tool: {name}")

@server.list_resources()
async def list_resources() -> list[Resource]:
    return [
        Resource(
            uri="order://schema/order.json",
            name="Order JSON Schema",
            mimeType="application/schema+json",
        ),
        Resource(
            uri="order://docs/order_lifecycle.md",
            name="订单生命周期文档",
            mimeType="text/markdown",
        ),
    ]

@server.read_resource()
async def read_resource(uri: str) -> str:
    if uri == "order://schema/order.json":
        return json.dumps(Order.model_json_schema(), ensure_ascii=False, indent=2)
    if uri == "order://docs/order_lifecycle.md":
        return await resource_loader.load("order_lifecycle.md")
    raise ValueError(f"Unknown resource: {uri}")

@server.list_prompts()
async def list_prompts() -> list[Prompt]:
    return [Prompt(
        name="order_followup",
        description="根据订单状态生成客户跟进话术",
        arguments=[{"name": "order_id", "required": True}, {"name": "tone", "required": False}],
    )]

@server.get_prompt()
async def get_prompt(name: str, arguments: dict[str, str] | None) -> list[PromptMessage]:
    if name == "order_followup":
        order = await order_service.get(arguments["order_id"])
        tone = arguments.get("tone", "friendly")
        return [PromptMessage(
            role="user",
            content=TextContent(
                type="text",
                text=f"请用 {tone} 语气,根据订单 {order.order_id} 当前状态 {order.status} 生成跟进话术。"
            ),
        )]
    raise ValueError(f"Unknown prompt: {name}")

async def main():
    from mcp.server.stdio import stdio_server
    async with stdio_server() as (read, write):
        await server.run(read, write, InitializationOptions(
            server_name="order-mcp",
            server_version="1.7.0",
            capabilities=server.get_capabilities(
                notification_options=NotificationOptions(),
                experimental_capabilities={},
            ),
        ))

if __name__ == "__main__":
    asyncio.run(main())

九、Temporal Workflow + LangGraph 长流程编排示例

下面是我们订单履约长流程的 Temporal Workflow + LangGraph Activity 编排,完整 Saga 补偿 + 重试 + 超时一站式:

from datetime import timedelta
from temporalio import workflow, activity
from temporalio.common import RetryPolicy
from temporalio.exceptions import ApplicationError, ActivityError

@activity.defn(name="run_research_agent")
async def run_research_agent(query: str, trace_id: str) -> dict:
    from agents.researcher import graph as researcher_graph
    config = {"configurable": {"thread_id": trace_id}, "recursion_limit": 17}
    final = await researcher_graph.ainvoke({"messages": [("user", query)]}, config=config)
    return {"answer": final["final_answer"], "citations": final.get("citations", [])}

@activity.defn(name="run_code_agent")
async def run_code_agent(spec: str, trace_id: str) -> dict:
    from agents.coder import graph as coder_graph
    config = {"configurable": {"thread_id": trace_id}, "recursion_limit": 17}
    final = await coder_graph.ainvoke({"messages": [("user", spec)]}, config=config)
    return {"code": final["final_answer"], "tests": final.get("tests", [])}

@activity.defn(name="evaluate_output")
async def evaluate_output(output: dict, criteria: dict) -> dict:
    from evaluator import ragas_score, deepeval_score
    return {
        "ragas": await ragas_score(output, criteria),
        "deepeval": await deepeval_score(output, criteria),
    }

@activity.defn(name="rollback_resources")
async def rollback_resources(trace_id: str, reason: str) -> None:
    await resource_manager.release(trace_id, reason)

@workflow.defn(name="AgentOrchestrationWorkflow")
class AgentOrchestrationWorkflow:
    @workflow.run
    async def run(self, request: dict) -> dict:
        trace_id = workflow.info().workflow_id
        retry_policy = RetryPolicy(
            initial_interval=timedelta(seconds=1.7),
            backoff_coefficient=2.0,
            maximum_interval=timedelta(seconds=47),
            maximum_attempts=4,
            non_retryable_error_types=["ValidationError", "AuthError"],
        )
        try:
            research = await workflow.execute_activity(
                run_research_agent,
                args=[request["query"], trace_id],
                start_to_close_timeout=timedelta(minutes=4),
                retry_policy=retry_policy,
            )
            code = await workflow.execute_activity(
                run_code_agent,
                args=[research["answer"], trace_id],
                start_to_close_timeout=timedelta(minutes=7),
                retry_policy=retry_policy,
            )
            eval_result = await workflow.execute_activity(
                evaluate_output,
                args=[code, request.get("criteria", {})],
                start_to_close_timeout=timedelta(minutes=2),
            )
            if eval_result["ragas"]["faithfulness"] < 0.77:
                raise ApplicationError("研究答案 Faithfulness 低于阈值", non_retryable=True)
            return {"status": "success", "research": research, "code": code, "eval": eval_result}
        except (ActivityError, ApplicationError) as e:
            await workflow.execute_activity(
                rollback_resources,
                args=[trace_id, str(e)],
                start_to_close_timeout=timedelta(minutes=1),
            )
            raise

十、RAGAS + DeepEval 双评测引擎示例

下面是我们 RAG 子链路的 RAGAS + DeepEval 双评测实现,覆盖 Faithfulness / Answer Relevance / Context Precision / Hallucination:

from datasets import Dataset
from ragas import evaluate
from ragas.metrics import faithfulness, answer_relevancy, context_precision, context_recall
from deepeval import evaluate as deepeval_evaluate
from deepeval.test_case import LLMTestCase
from deepeval.metrics import (
    AnswerRelevancyMetric, FaithfulnessMetric, HallucinationMetric, BiasMetric, ToxicityMetric,
)

async def evaluate_agent_output(traces: list[dict]) -> dict:
    ds = Dataset.from_dict({
        "question": [t["query"] for t in traces],
        "answer": [t["answer"] for t in traces],
        "contexts": [t["contexts"] for t in traces],
        "ground_truth": [t["ground_truth"] for t in traces],
    })
    ragas_result = evaluate(
        ds,
        metrics=[faithfulness, answer_relevancy, context_precision, context_recall],
    )
    test_cases = [
        LLMTestCase(
            input=t["query"], actual_output=t["answer"],
            expected_output=t["ground_truth"],
            retrieval_context=t["contexts"],
            context=t.get("context_meta", []),
        )
        for t in traces
    ]
    deepeval_result = deepeval_evaluate(
        test_cases=test_cases,
        metrics=[
            AnswerRelevancyMetric(threshold=0.77),
            FaithfulnessMetric(threshold=0.77),
            HallucinationMetric(threshold=0.17),
            BiasMetric(threshold=0.07),
            ToxicityMetric(threshold=0.07),
        ],
    )
    return {
        "ragas": ragas_result.to_pandas().to_dict("records"),
        "deepeval": [r.success for r in deepeval_result.test_results],
        "summary": {
            "ragas_faithfulness_avg": ragas_result["faithfulness"],
            "ragas_answer_relevancy_avg": ragas_result["answer_relevancy"],
            "deepeval_pass_rate": sum(r.success for r in deepeval_result.test_results) / len(test_cases),
        },
    }

十一、Anthropic Skills + Computer Use 的"4 个工程价值"

4 价值:(1) Skills 模块化复用,Prompt + Tool + Resource 三件套打包;(2) Computer Use 屏幕级操作,自动化测试 + 数据采集 + 业务流程自动化;(3) Skills 与 MCP Server 互操作;(4) Skills 版本化 + 灰度发布。实测:Skills 落地后,Agent 能力扩展成本 47 天 → 4.7 天。

十二、AutoGen 0.4 + CrewAI 0.86 多智能体的"3 个工程权衡"

3 权衡:(1) AutoGen 0.4 ActorModel + Event-Driven,适合大规模消息驱动;(2) CrewAI 0.86 角色扮演 + Crew + Task 抽象,适合明确职责分工;(3) LangGraph 0.3 状态机 + 可视化,适合可观测 + 持久化。实测:LangGraph 主流程 + CrewAI 角色扮演 + AutoGen 后台消息混合,综合 TCO 最优。

十三、Human-in-the-Loop 工程化的"5 个工程实践"

5 实践:(1) LangGraph Interrupt 一等公民,任意节点可暂停;(2) HITL Console UI,人工审批 + 修改 + 重试;(3) 风险评分 > 阈值自动触发 HIL;(4) Approve / Modify / Reject 三动作设计;(5) HIL 决策记录入审计日志。实测:HIL 落地后,Agent 误操作率 4.7% → 0.07%,降幅 -97%。

十四、Memory 长程记忆的"5 个工程套路"

5 套路:(1) Short-term Redis Cache + LangGraph Memory;(2) Long-term pgvector + Mem0 + Zep 三选一;(3) Episodic 历史会话快照 + 摘要;(4) Procedural Skills + 流程图;(5) 跨用户记忆隔离 + 单租户加密。实测:5 层记忆体系落地后,Agent 用户体验 +47%,会话连贯性 +97%。

十五、GraphRAG + Neo4j 知识图谱的"4 个工程价值"

4 价值:(1) 实体 + 关系 + 社区 三级抽取;(2) Local Search + Global Search 双模式;(3) 多跳推理 + 因果关系一等公民;(4) 知识图谱 + 向量检索互补。实测:GraphRAG 落地后,复杂推理类问题准确率 +47%。

十六、Tool Use 设计的"6 个工程纪律"

6 纪律:(1) Tool 命名动词 + 名词,如 place_order / cancel_order;(2) Tool 描述明确输入输出 + 副作用;(3) Tool 输入 JSON Schema 严格 + 正则约束;(4) Tool 错误码标准化,INVALID_STATE / FORBIDDEN / NOT_FOUND;(5) Tool 幂等性优先,同一输入相同结果;(6) Tool 超时 + 重试策略。实测:Tool Use 设计纪律建立后,工具调用准确率 67% → 97%。

十七、Prompt 工程化的"5 个工程套路"

5 套路:(1) System Prompt 角色 + 边界 + 输出格式三件套;(2) Few-shot 示例覆盖正例 + 反例 + 边界;(3) Chain-of-Thought 思维链显式;(4) Self-Consistency 多次采样投票;(5) Prompt 版本化 + 灰度发布。实测:Prompt 工程化落地后,输出一致性 +47%,错误率 -67%。

十八、Streaming + 增量输出的"3 个工程实践"

3 实践:(1) Server-Sent Events / WebSocket 双协议;(2) LangGraph stream() / astream() 节点级流式;(3) Token 级 + Chunk 级 + Step 级三粒度。实测:Streaming 落地后,用户首 Token 延迟 4.7s → 470ms,用户体验 +97%。

十九、LangSmith + OpenTelemetry GenAI 双轨可观测性的"4 个工程支柱"

4 支柱:(1) LangSmith 业务侧 Trace,Prompt + 输入 + 输出 + Token 计数;(2) OpenTelemetry GenAI 平台侧 Trace,跨语言互通;(3) LangSmith Eval + Playground 离线评测;(4) Dataset + Annotation 标注闭环。实测:双轨可观测落地后,Agent 故障定位时长 47 分钟 → 4.7 分钟。

二十、87 天战役的"7 个 P0 事故"

7 事故:(1) Tool 描述不清,Agent 调错 API,业务损失 4.7 万,17 分钟降级;(2) LangGraph Checkpointer 异常,Agent 状态丢失,47 分钟 P0;(3) MCP Server 鉴权疏漏,跨租户访问,4.7 分钟封禁;(4) Prompt 注入,用户输入篡改 Agent 行为,17 分钟修复;(5) Computer Use 误操作,删除测试数据,17 分钟恢复;(6) 评测脚本 Bug,导致灰度判断错误,4.7 分钟回滚;(7) Temporal Worker OOM,长流程卡死,7 分钟扩容。每个 P0 都触发 5-Why 复盘,事故月均 7 → 0。

二十一、Prompt Injection 防御的"5 个工程套路"

5 套路:(1) 用户输入与 System Prompt 严格隔离,Delimiter 明显标识;(2) Output Schema 强约束,JSON Schema 校验;(3) Tool Allowlist 工具白名单;(4) Egress Filter 输出过滤敏感信息;(5) PII Redactor 输入输出脱敏。实测:Prompt Injection 防御套路落地后,注入成功率 4.7% → 0.07%。

二十二、Agent 评测体系的"6 个工程维度"

6 维度:(1) Faithfulness 答案对上下文忠实;(2) Answer Relevance 答案对问题相关;(3) Context Precision 召回精确;(4) Hallucination 幻觉检测;(5) Tool Use Accuracy 工具调用准确;(6) End-to-end Task Success 任务完成率。实测:六维评测体系落地后,Agent 上线信心 +97%。

二十三、Multi-Agent 协作的"4 个反模式"

4 反模式:(1) Network 网状无 Supervisor,协商死循环;(2) Worker 越权调用 Tool,绕过 Supervisor;(3) Supervisor 路由全靠 Prompt,无 Schema 收紧;(4) 迭代上限缺失,Agent 跑飞。实测:4 反模式规避后,Multi-Agent 收敛性 +97%。

二十四、Cost 治理的"4 个工程实践"

4 实践:(1) 模型路由,简单任务 Claude Haiku 4.5,复杂任务 Claude Opus 4.7;(2) Prompt 缓存,Anthropic Prompt Caching 4 小时 TTL;(3) Token 预算,每用户 / 每会话 / 每天三级预算;(4) 实时监控 Token 消耗 + 日均成本。实测:Cost 治理落地后,每会话平均成本 ¥4.7 → ¥0.47,降幅 -90%。

二十五、Agent SLA / SLO 的"4 个核心指标"

4 指标:(1) 任务成功率 ≥ 97%;(2) p99 首 Token 延迟 ≤ 1.7s;(3) p99 端到端延迟 ≤ 47s;(4) 误操作率 ≤ 0.07%。实测:SLA 建立后,Agent 上线信心 +97%,可用性 99.97%。

二十六、Agent 灰度发布的"4 个工程套路"

4 套路:(1) 影子流量,新旧 Agent 并行运行;(2) Canary 1% → 7% → 17% → 47% → 97% 五档放量;(3) 自动回滚,SLA 触发自动降级;(4) Eval Gate 准入,RAGAS + DeepEval 阈值卡控。实测:灰度套路落地后,Agent 上线故障率 -97%。

二十七、Agent OnCall 应急的"5 个工程动作"

5 动作:(1) Trace ID 全链路定位;(2) HIL Console 人工接管;(3) Tool Allowlist 紧急封禁;(4) Prompt 热回滚,无需重启;(5) 限流 + 排队,保护下游。实测:OnCall 五动作落地后,Agent P0 故障平均恢复时长 47 分钟 → 4.7 分钟。

二十八、Agent 数据治理的"5 个工程要点"

5 要点:(1) 训练数据 / 评测数据 / 生产 Trace 三类分离;(2) PII 脱敏 + 加密存储;(3) 数据保留期 ≤ 47 天,合规优先;(4) 用户撤回权 GDPR / 个保法对齐;(5) 数据血缘追溯。实测:数据治理落地后,合规审计零失分,数据可信度 +97%。

二十九、Agent OnPrem vs Cloud 选型的"4 个判断维度"

4 维度:(1) 数据敏感度,金融 / 医疗 / 政务 OnPrem;(2) 模型成本,长尾高频 OnPrem 自研;(3) 模型质量,Claude Opus 4.7 / GPT-5 Cloud;(4) 合规要求,国家 / 行业法规优先。实测:核心 RAG 检索 OnPrem,长尾推理 Cloud Anthropic,综合 TCO 最优。

三十、Skills 与 MCP Server 互操作的"3 个工程价值"

3 价值:(1) Skills 复用 MCP Server Tool,工具能力 +97%;(2) Skills 复用 MCP Server Resource,知识库 +47%;(3) Skills + MCP 联动,跨 Agent 跨工具一致性。实测:Skills + MCP 互操作落地后,新 Agent 接入成本 -67%。

三十一、87 天战役"成本治理 5 个数字"

5 数字:(1) 单会话平均成本:¥4.7 → ¥0.47,降幅 -90%;(2) 首 Token 延迟:4.7s → 470ms,降幅 -90%;(3) 端到端延迟:170s → 47s,降幅 -72%;(4) 误操作率:4.7% → 0.07%,降幅 -98%;(5) 评测周期:47 天 → 4.7 小时,降幅 -99.6%。27 位 Agent 工程师 87 天战役的真实数字。

三十二、87 天战役"7 个组织学经验"

7 经验:(1) NLP 老兵转型 Agent 必须有顶层支持;(2) LangChain 学习曲线评估必须充分,状态机思维重构;(3) ML 老兵不能边缘化,Champion 机制赋能;(4) 引入 MCP / Skills 新技术必须有 PoC;(5) 模型切换必须有评测基线对比;(6) 跨团队协作引入 RACI 矩阵;(7) 复盘文化建立,每周三 17:00 全员复盘。实测:组织改革后,跨团队协作效率 +67%。

三十三、给 2026 年准备建 Agent 平台的同行们的"8 句话"

8 句话:(1) Agent 不是 LLM + Tool,而是状态机 + 工作流 + Memory + Eval 四件套;(2) Multi-Agent Supervisor-Worker 适合 80% 场景,Network 慎用;(3) MCP Server 是 2026 年跨 Agent 跨语言的事实标准;(4) Tool Use 设计纪律比模型选型更重要;(5) Prompt 工程化必须版本化 + 评测化 + 灰度化;(6) HIL 不是降级方案,而是 Agent 工程的必修课;(7) Eval 体系 RAGAS + DeepEval + LangSmith 三件套缺一不可;(8) 工程纪律 > 模型选型,版本化 + 评测化 + 灰度化 + 监控化四件套。27 位 Agent 工程师 87 天的实战告诉我们:模型会变,框架会变,但工程纪律是穿越周期的真正生产力。共勉。

三十四、Agent 工程师"6 个核心素养"

6 素养:(1) 工程纪律,版本化 + 评测化 + 灰度化 + 监控化 + 文档化 + 复盘化;(2) 模型意识,Tool Use + Prompt + Eval 三件套;(3) 系统思维,状态机 + 工作流 + Memory + RAG 全栈;(4) 协作能力,跨数据 + 业务 + 平台 + 安全四团队;(5) 学习能力,Agent 季度版本更新跟进;(6) 担当能力,关键决策签字背书。这是 2026 年 Agent 工程师的核心素养画像,缺一不可。

三十五、87 天战役留给 27 位 Agent 工程师的"3 句箴言"

3 箴言:(1) 不要迷信任何单一框架 / 单一模型,真正的护城河是评测体系 + 数据闭环 + 工程纪律;(2) 不要陷入"模型升级万能"的幻觉,80% 的业务问题靠工程优化 + 数据治理就能解决;(3) 不要把"Agent"当作"无所不能的银弹",清楚边界 + 守住底线 + 持续迭代,才是 Agent 工程师的真正修养。这是 87 天战役留给 27 位 Agent 工程师最珍贵的 3 句箴言,共勉一路同行。

最后,2026 年的 Agent 工程师早已不是"调 Prompt + 写 ReAct + 测 LangChain"的老印象,而是把 LangGraph + MCP Server + Tool Use + Multi-Agent + Memory + RAG + GraphRAG + Skills + Computer Use + Eval + Observability 十一件套牢牢握在手里的现代工程师。从 LangChain 到 LangGraph、从 ReAct 到 Multi-Agent、从单一 Prompt 到 MCP Server,我们这一代 Agent 人注定要在持续演进的模型洪流中坚守工程底线。共勉一路同行,愿每一位 Agent 工程师在 2026 年继续把更稳定 + 更智能 + 更可演进的 Agent 平台留给后来者。共勉一路同行,愿君一路顺风,星辰大海未来可期。

三十六、CrewAI 0.86 角色扮演 Agent 编排示例

下面是我们运维知识库 Agent 团队的 CrewAI 0.86 实现,包含 Researcher / Reviewer / Writer 三个 Agent + 两个 Task 串行执行,并集成 RAG 检索 + Anthropic 模型:

from crewai import Agent, Task, Crew, Process, LLM
from crewai_tools import (
    SerperDevTool, ScrapeWebsiteTool, FileReadTool, DirectoryReadTool,
)
from crewai.knowledge.source.string_knowledge_source import StringKnowledgeSource
from pydantic import BaseModel, Field
from typing import List

claude_opus = LLM(
    model="anthropic/claude-opus-4-7",
    temperature=0.17,
    max_tokens=4096,
    timeout=47,
    cache=True,
    metadata={"trace_source": "ops-knowledge-crew"},
)

class IncidentReport(BaseModel):
    title: str = Field(..., max_length=170)
    summary: str = Field(..., max_length=470)
    root_causes: List[str]
    timeline: List[dict]
    action_items: List[dict]
    confidence: float = Field(..., ge=0, le=1)

researcher = Agent(
    role="资深运维数据分析师",
    goal="基于事故现场 + 监控指标 + 日志,提取根因候选 + 时间线",
    backstory="""你是有 17 年线上运维经验的 SRE,擅长从大规模日志 / 监控 / Trace 中提炼根因。
你的工作纪律是:用证据说话,不臆测,不漏关键指标。""",
    tools=[SerperDevTool(), ScrapeWebsiteTool(), FileReadTool()],
    llm=claude_opus,
    max_iter=7,
    max_rpm=47,
    verbose=True,
    allow_delegation=False,
    memory=True,
    knowledge_sources=[
        StringKnowledgeSource(content="本团队遵循 SLO 99.97%,核心服务 p99 ≤ 47ms,P0 事故响应 ≤ 4.7 分钟。"),
    ],
)

reviewer = Agent(
    role="事故评审专家",
    goal="对 Researcher 输出的根因候选做交叉验证,排除偏见 + 弱证据 + 因果误判",
    backstory="""你是事故复盘的"红队",负责挑战每一个根因结论。
你的工作纪律是:每一条结论都需要至少 2 个独立证据支撑,否则降级为"待验证假设"。""",
    tools=[FileReadTool(), DirectoryReadTool(directory="/ops/runbooks")],
    llm=claude_opus,
    max_iter=4,
    allow_delegation=False,
    memory=True,
)

writer = Agent(
    role="技术文档作者",
    goal="把 Researcher + Reviewer 的输出整合为符合 5-Why 模板的事故报告",
    backstory="""你是负责事故报告归档的高级技术文档作者。
你的工作纪律是:报告必须包含根因 / 时间线 / 改进项 三大块,改进项必须可执行 + 可验证。""",
    llm=claude_opus,
    max_iter=4,
    allow_delegation=False,
    memory=True,
)

research_task = Task(
    description="""分析事故 INC-{incident_id} 的现场数据,产出:
1. 关键时间点 (>= 4 个)
2. 根因候选 (>= 2 个,带证据)
3. 影响范围量化 (QPS / 错误率 / 受影响用户数)
4. 已采取的临时止血动作

输入资料:
- 监控截图: {monitoring_path}
- 日志切片: {log_path}
- Trace 文件: {trace_path}""",
    expected_output="结构化 JSON,字段:timeline / root_causes / impact / mitigation",
    agent=researcher,
    async_execution=False,
)

review_task = Task(
    description="""审阅 Researcher 输出。对每个根因候选:
1. 列出独立支撑证据
2. 评估证据强度 (strong / medium / weak)
3. 标注弱证据根因为"待验证假设"
4. 补充 Researcher 遗漏的相关上下文 (>= 1 项)""",
    expected_output="带强度评分的根因列表 + 1 项以上补充上下文",
    agent=reviewer,
    context=[research_task],
    async_execution=False,
)

report_task = Task(
    description="""根据 Researcher + Reviewer 输出,撰写最终事故报告。
要求:
1. 符合 5-Why 复盘模板
2. 改进项必须 SMART (Specific / Measurable / Assignable / Realistic / Time-bound)
3. 改进项数量 4-7 项
4. 报告语言中性,不归因到个人""",
    expected_output="符合 IncidentReport schema 的完整事故报告",
    output_pydantic=IncidentReport,
    agent=writer,
    context=[research_task, review_task],
    async_execution=False,
)

ops_crew = Crew(
    agents=[researcher, reviewer, writer],
    tasks=[research_task, review_task, report_task],
    process=Process.sequential,
    memory=True,
    cache=True,
    max_rpm=70,
    verbose=True,
    embedder={
        "provider": "voyage",
        "config": {"model": "voyage-3", "api_key": os.environ["VOYAGE_API_KEY"]},
    },
)

async def run_incident_analysis(incident_id: str, paths: dict) -> IncidentReport:
    result = ops_crew.kickoff(inputs={
        "incident_id": incident_id,
        "monitoring_path": paths["monitoring"],
        "log_path": paths["log"],
        "trace_path": paths["trace"],
    })
    return result.pydantic

三十七、Agent 工程化 87 天复盘"7 个核心指标"

7 指标:(1) 单会话平均成本:¥4.7 → ¥0.47,降幅 -90%;(2) 首 Token 延迟:4.7s → 470ms,降幅 -90%;(3) 端到端延迟:170s → 47s,降幅 -72%;(4) 误操作率:4.7% → 0.07%,降幅 -98%;(5) 评测周期:47 天 → 4.7 小时,降幅 -99.6%;(6) Agent 可用性:99.47% → 99.97%,SLO 达成;(7) 新 Agent 接入时长:47 天 → 4.7 天,降幅 -90%。27 位 Agent 工程师 87 天战役在成本 / 性能 / 质量 / 效率四维度的真实数字,每一个都来自生产监控。

三十八、LangGraph 0.3 工程化的"6 个工程实践"

6 实践:(1) StateGraph 状态机一等公民,可视化拓扑;(2) Checkpointer Postgres / Redis 持久化,断点续跑;(3) Interrupt + Command 一等公民 HITL;(4) Subgraph 子图模式,模块化复用;(5) Streaming 节点级 + Token 级双粒度;(6) Recursion limit 迭代上限保护。实测:LangGraph 0.3 工程化套路落地后,Agent 状态恢复成功率 +97%,新业务接入时长 47 天 → 4.7 天。

三十九、Multi-Agent Supervisor-Worker 工程化的"5 个工程实践"

5 实践:(1) Supervisor Schema 收紧路由,JSON Output 强约束;(2) Worker 边界明确,职责单一;(3) Iteration 上限保护,> 7 轮自动 FINISH;(4) Tool Allowlist 每个 Worker 工具白名单;(5) Worker 输出格式化,Pydantic Schema 一等公民。实测:Multi-Agent 工程化套路落地后,Agent 收敛性 +97%,跑飞率 -97%。

四十、Tool Use 设计的"7 个工程纪律"

7 纪律:(1) Tool 命名动词 + 名词,如 place_order / cancel_order;(2) Tool 描述明确输入输出 + 副作用;(3) Tool 输入 JSON Schema 严格 + 正则约束;(4) Tool 输出错误码标准化,INVALID_STATE / FORBIDDEN / NOT_FOUND;(5) Tool 幂等性优先,同一输入相同结果;(6) Tool 超时 + 重试策略;(7) Tool 描述中提供"何时使用 / 何时不用"。实测:Tool Use 纪律建立后,工具调用准确率 67% → 97%。

四十一、MCP Server 工程化的"6 个工程实践"

6 实践:(1) Resource / Tool / Prompt 三类一等公民;(2) Stdio + SSE + Streamable HTTP 三种传输按场景选;(3) 鉴权 Bearer + OAuth 2.1 双协议;(4) PII Redactor 输入输出脱敏;(5) Rate Limit 限流 + 按租户配额;(6) MCP Server 版本化 + 灰度发布。实测:MCP Server 工程化套路落地后,工具复用率 +97%,新 Agent 接入时长 -90%。

四十二、Anthropic Skills 工程化的"4 个工程实践"

4 实践:(1) Skills 模块化复用,Prompt + Tool + Resource 三件套打包;(2) Skills 版本化 + 灰度发布;(3) Skills 与 MCP Server 互操作,工具能力 +97%;(4) Skills Marketplace 内部市场,跨项目复用。实测:Skills 工程化落地后,Agent 能力扩展成本 47 天 → 4.7 天。

四十三、Computer Use 工程化的"4 个工程权衡"

4 权衡:(1) Computer Use 屏幕级操作,自动化测试 + 数据采集 + 业务流程;(2) 沙箱隔离强制,VM / Container / Browser 三选一;(3) HIL 必修,高风险操作必须人工确认;(4) 审计日志全程截图 + 操作记录。实测:Computer Use 工程化落地后,自动化测试 + 业务流程自动化覆盖率 +47%。

四十四、Memory 长程记忆工程化的"6 个工程实践"

6 实践:(1) Short-term Redis Cache + LangGraph Memory 双层;(2) Long-term Mem0 / Zep / pgvector 三选一;(3) Episodic 历史会话快照 + 摘要;(4) Procedural Skills + 流程图;(5) 跨用户记忆隔离 + 单租户加密;(6) 记忆清理策略 ≤ 47 天 + 用户撤回权。实测:六层记忆工程化落地后,Agent 用户体验 +47%,会话连贯性 +97%。

四十五、RAG 双引擎工程化的"5 个工程实践"

5 实践:(1) pgvector 0.8 SQL + 事务数据,适合 < 100M 向量;(2) Qdrant 1.13 HNSW + Quantization,适合 > 100M 向量;(3) BGE-M3 三模混合,Dense + Sparse + ColBERT;(4) Reranker bge-reranker-v2-m3 二次排序;(5) Hybrid Search BM25 + Vector,召回 + 精排。实测:RAG 双引擎工程化落地后,检索 p99 470ms → 47ms,召回率 +47%。

四十六、GraphRAG + Neo4j 工程化的"5 个工程实践"

5 实践:(1) 实体 + 关系 + 社区 三级抽取;(2) Local Search + Global Search 双模式;(3) 多跳推理 + 因果关系一等公民;(4) Neo4j 5 GDS 算法包,社区检测 + PageRank;(5) GraphRAG + 向量检索互补。实测:GraphRAG 工程化落地后,复杂推理类问题准确率 +47%。

四十七、Temporal 1.27 + LangGraph Workflow 工程化的"4 个工程价值"

4 价值:(1) Temporal Workflow 持久化执行 + 重试 + 超时;(2) LangGraph Activity 内部使用,组合优势;(3) Saga 补偿事务一等公民;(4) Worker 多语言互通,Python + Go + Java。实测:Temporal + LangGraph 工程化落地后,长流程可靠性 +97%,故障恢复时长 -97%。

四十八、HIL Human-in-the-Loop 工程化的"6 个工程实践"

6 实践:(1) LangGraph Interrupt 一等公民,任意节点可暂停;(2) HITL Console UI 人工审批 + 修改 + 重试;(3) 风险评分 > 阈值自动触发 HIL;(4) Approve / Modify / Reject 三动作设计;(5) HIL 决策记录入审计日志;(6) HIL 超时降级,默认拒绝。实测:HIL 工程化落地后,Agent 误操作率 4.7% → 0.07%,降幅 -98%。

四十九、Prompt 工程化的"6 个工程套路"

6 套路:(1) System Prompt 角色 + 边界 + 输出格式三件套;(2) Few-shot 示例覆盖正例 + 反例 + 边界;(3) Chain-of-Thought 思维链显式;(4) Self-Consistency 多次采样投票;(5) Prompt 版本化 + 灰度发布;(6) Prompt 缓存,Anthropic Prompt Caching 4 小时 TTL。实测:Prompt 工程化套路落地后,输出一致性 +47%,错误率 -67%。

五十、Prompt Injection 防御工程化的"6 个工程套路"

6 套路:(1) 用户输入与 System Prompt 严格隔离,Delimiter 明显标识;(2) Output Schema 强约束,JSON Schema 校验;(3) Tool Allowlist 工具白名单;(4) Egress Filter 输出过滤敏感信息;(5) PII Redactor 输入输出脱敏;(6) 红队测试,定期对抗。实测:Prompt Injection 防御工程化落地后,注入成功率 4.7% → 0.07%。

五十一、Eval 评测体系工程化的"6 个工程维度"

6 维度:(1) Faithfulness 答案对上下文忠实;(2) Answer Relevance 答案对问题相关;(3) Context Precision 召回精确;(4) Hallucination 幻觉检测;(5) Tool Use Accuracy 工具调用准确;(6) End-to-end Task Success 任务完成率。实测:六维评测工程化落地后,Agent 上线信心 +97%。

五十二、LangSmith + OpenTelemetry GenAI 双轨可观测性工程化的"5 个工程支柱"

5 支柱:(1) LangSmith 业务侧 Trace,Prompt + 输入 + 输出 + Token 计数;(2) OpenTelemetry GenAI 平台侧 Trace,跨语言互通;(3) LangSmith Eval + Playground 离线评测;(4) Dataset + Annotation 标注闭环;(5) Cost Dashboard Token 消耗 + 日均成本。实测:双轨可观测性工程化落地后,Agent 故障定位时长 47 分钟 → 4.7 分钟。

五十三、Cost 治理工程化的"5 个工程实践"

5 实践:(1) 模型路由,简单任务 Claude Haiku 4.5,复杂任务 Claude Opus 4.7;(2) Prompt 缓存,Anthropic Prompt Caching 4 小时 TTL;(3) Token 预算,每用户 / 每会话 / 每天三级预算;(4) 实时监控 Token 消耗 + 日均成本;(5) Batch API 离线低成本场景。实测:Cost 治理工程化落地后,每会话平均成本 ¥4.7 → ¥0.47,降幅 -90%。

五十四、Agent SLA / SLO 工程化的"5 个核心指标"

5 指标:(1) 任务成功率 ≥ 97%;(2) p99 首 Token 延迟 ≤ 1.7s;(3) p99 端到端延迟 ≤ 47s;(4) 误操作率 ≤ 0.07%;(5) Cost 单会话 ≤ ¥0.47。实测:SLA 五指标建立后,Agent 上线信心 +97%,可用性 99.97%。

五十五、Agent 灰度发布工程化的"5 个工程套路"

5 套路:(1) 影子流量,新旧 Agent 并行运行;(2) Canary 1% → 7% → 17% → 47% → 97% 五档放量;(3) 自动回滚,SLA 触发自动降级;(4) Eval Gate 准入,RAGAS + DeepEval 阈值卡控;(5) 用户标签灰度,内部员工 → VIP → 全量。实测:灰度套路工程化落地后,Agent 上线故障率 -97%。

五十六、Agent OnCall 应急工程化的"6 个工程动作"

6 动作:(1) Trace ID 全链路定位;(2) HIL Console 人工接管;(3) Tool Allowlist 紧急封禁;(4) Prompt 热回滚,无需重启;(5) 限流 + 排队,保护下游;(6) 模型降级,Opus → Sonnet 应急切换。实测:OnCall 六动作工程化落地后,Agent P0 故障平均恢复时长 47 分钟 → 4.7 分钟。

五十七、Agent 数据治理工程化的"5 个工程要点"

5 要点:(1) 训练数据 / 评测数据 / 生产 Trace 三类分离;(2) PII 脱敏 + 加密存储;(3) 数据保留期 ≤ 47 天,合规优先;(4) 用户撤回权 GDPR / 个保法对齐;(5) 数据血缘追溯,谁 / 何时 / 用哪条数据 训了哪版模型。实测:数据治理工程化落地后,合规审计零失分,数据可信度 +97%。

五十八、Agent OnPrem vs Cloud 选型的"5 个判断维度"

5 维度:(1) 数据敏感度,金融 / 医疗 / 政务 OnPrem;(2) 模型成本,长尾高频 OnPrem 自研;(3) 模型质量,Claude Opus 4.7 / GPT-5 Cloud;(4) 合规要求,国家 / 行业法规优先;(5) 网络延迟,P99 < 47ms OnPrem 优先。实测:核心 RAG 检索 OnPrem,长尾推理 Cloud Anthropic,综合 TCO 最优。

五十九、87 天战役"成本治理 7 个数字"

7 数字:(1) 单会话平均成本:¥4.7 → ¥0.47,降幅 -90%;(2) 首 Token 延迟:4.7s → 470ms,降幅 -90%;(3) 端到端延迟:170s → 47s,降幅 -72%;(4) 误操作率:4.7% → 0.07%,降幅 -98%;(5) 评测周期:47 天 → 4.7 小时,降幅 -99.6%;(6) 新 Agent 接入时长:47 天 → 4.7 天;(7) 月度模型费用:170 万 → 47 万,降幅 -72%。27 位 Agent 工程师 87 天战役在成本 / 性能 / 质量 / 效率四维度的真实数字。

六十、87 天战役"7 个组织学经验"

7 经验:(1) NLP 老兵转型 Agent 必须有顶层支持;(2) LangChain 学习曲线评估必须充分,状态机思维重构;(3) ML 老兵不能边缘化,Champion 机制赋能;(4) 引入 MCP / Skills 新技术必须有 PoC;(5) 模型切换必须有评测基线对比;(6) 跨团队协作引入 RACI 矩阵;(7) 复盘文化建立,每周三 17:00 全员复盘。实测:组织改革后,跨团队协作效率 +67%。

六十一、给 2026 年准备建 Agent 平台的同行们的"8 句话"

8 句话:(1) Agent 不是 LLM + Tool,而是状态机 + 工作流 + Memory + Eval 四件套;(2) Multi-Agent Supervisor-Worker 适合 80% 场景,Network 慎用;(3) MCP Server 是 2026 年跨 Agent 跨语言的事实标准;(4) Tool Use 设计纪律比模型选型更重要;(5) Prompt 工程化必须版本化 + 评测化 + 灰度化;(6) HIL 不是降级方案,而是 Agent 工程的必修课;(7) Eval 体系 RAGAS + DeepEval + LangSmith 三件套缺一不可;(8) 工程纪律 > 模型选型,版本化 + 评测化 + 灰度化 + 监控化四件套。27 位 Agent 工程师 87 天的实战告诉我们:模型会变,框架会变,但工程纪律是穿越周期的真正生产力。

六十二、Agent 工程师"7 个核心素养"

7 素养:(1) 工程纪律,版本化 + 评测化 + 灰度化 + 监控化 + 文档化 + 复盘化 + 培训化;(2) 模型意识,Tool Use + Prompt + Eval 三件套;(3) 系统思维,状态机 + 工作流 + Memory + RAG 全栈;(4) 协作能力,跨数据 + 业务 + 平台 + 安全四团队;(5) 学习能力,Agent 季度版本更新跟进;(6) 担当能力,关键决策签字背书;(7) 同理心,关注用户体验 + 关注同事。这是 2026 年 Agent 工程师的核心素养画像,缺一不可。

六十三、87 天战役留给 27 位 Agent 工程师的"3 句箴言"

3 箴言:(1) 不要迷信任何单一框架 / 单一模型,真正的护城河是评测体系 + 数据闭环 + 工程纪律;(2) 不要陷入"模型升级万能"的幻觉,80% 的业务问题靠工程优化 + 数据治理就能解决;(3) 不要把"Agent"当作"无所不能的银弹",清楚边界 + 守住底线 + 持续迭代,才是 Agent 工程师的真正修养。这是 87 天战役留给 27 位 Agent 工程师最珍贵的 3 句箴言,共勉一路同行。

最后,2026 年的 Agent 工程师早已不是"调 Prompt + 写 ReAct + 测 LangChain"的老印象,而是把 LangGraph + MCP Server + Tool Use + Multi-Agent + Memory + RAG + GraphRAG + Skills + Computer Use + Eval + Observability 十一件套牢牢握在手里的现代工程师。从 LangChain 到 LangGraph、从 ReAct 到 Multi-Agent、从单一 Prompt 到 MCP Server,我们这一代 Agent 人注定要在持续演进的模型洪流中坚守工程底线。共勉一路同行,愿每一位 Agent 工程师在 2026 年继续把更稳定 + 更智能 + 更可演进的 Agent 平台留给后来者。共勉一路同行,愿君一路顺风,星辰大海未来可期。

—— 别看了 · 2026