从 MVP 到真实 Agent:接入大模型、异步任务与可靠执行

举报
yd_225949750 发表于 2026/11/13 10:21:00 2026/11/13
【摘要】 AI Agent 工程化实战第二阶段:用 FastAPI、PostgreSQL 和 OpenAI Agents SDK,把演示程序升级为可以持续运行的任务系统一、一个很常见的错误:把模型调用写进 API,就认为完成了 Agent 产品在上一篇《Production Agent Architecture》中,我们设计了一套生产级 Agent 的整体架构。它包含:FastAPI 负责接收任务。P...

AI Agent 工程化实战第二阶段:用 FastAPI、PostgreSQL 和 OpenAI Agents SDK,把演示程序升级为可以持续运行的任务系统


一、一个很常见的错误:把模型调用写进 API,就认为完成了 Agent 产品

在上一篇《Production Agent Architecture》中,我们设计了一套生产级 Agent 的整体架构。

它包含:

  • FastAPI 负责接收任务。

  • PostgreSQL 保存状态。

  • Agent Runtime 负责执行。

  • Tool Gateway 管理权限。

  • 审批机制控制副作用。

  • Evals 负责验证质量。

  • Observability 记录执行轨迹。

但当我们真正开始编写代码时,第一个版本往往是这样的:

@app.post("/research")
async def research(request: ResearchRequest):
    result = await Runner.run(
        research_agent,
        request.topic
    )
    return {"report": result.final_output}

这段代码确实能够调用模型。

对于简单、短时间的任务,它也完全可以正常工作。

但是,假设用户要求:

“研究过去24小时的AI行业动态,阅读官方公告,筛选重要事件,生成一份带来源的报告。”

一次执行可能需要几十次模型与工具调用。

可能运行数分钟。

这时会出现一系列问题。

用户关闭浏览器,任务怎么办?

API请求超时,任务是否还在运行?

服务重启,执行进度是否丢失?

模型生成一半失败,系统怎么恢复?

同一个任务被提交两次,会不会消耗双倍费用?

生成结果格式正确,是否意味着事实也正确?

如果没有这些答案,我们只是把大模型接入了Web服务,还没有完成真正的 Agent 工程化。

第十一篇要解决的,就是从同步 Demo 到可靠异步 Agent 的第一步。


二、今天我们要交付什么?

继续沿用前一篇的企业研究助手 ResearchOps。

但本次只实现一条完整主路径:

提交研究主题 → 后台执行 → 模型生成结构化报告 → 验证 → 保存结果 → 用户查询。

目标接口:

接口 作用
POST /tasks 创建研究任务
GET /tasks/{id} 查询任务状态
GET /tasks/{id}/result 获取研究结果
GET /healthz 健康检查

用户提交任务之后,服务立即返回任务ID。

真正的模型调用由独立 Worker 执行。

这样可以将用户请求与耗时任务分离。

推荐的执行流程

                  User
                    |
                    v
             POST /tasks
                    |
                    v
              FastAPI API
                    |
                    v
             PostgreSQL
              status=queued
                    |
                    v
              HTTP 202
               + task_id
                    |
                    v
               Task Worker
                    |
                    v
               Agent Runner
                    |
             +------+------+
             |             |
             v             v
          LLM Call      Read Tools
             |             |
             +------+------+
                    |
                    v
             Structured Result
                    |
                    v
              Validation
                    |
                    v
              PostgreSQL
            status=completed
                    |
                    v
           GET /tasks/{id}

这是一条非常简单的主链路。

但它包含了两个重要的边界:

HTTP请求负责创建任务,不负责一直等待模型执行。

模型负责生成内容,可信程序负责验证与保存业务状态。


三、为什么不直接使用 FastAPI BackgroundTasks?

FastAPI 提供 BackgroundTasks,开发起来很方便。

例如:

@app.post("/tasks")
def create_task(background_tasks: BackgroundTasks):
    background_tasks.add_task(run_research)
    return {"accepted": True}

对于简单通知、短耗时操作,它是一项很好用的能力。

但当任务需要:

  • 持续几分钟。

  • 多次模型调用。

  • 服务重启后恢复。

  • 并发数量控制。

  • 可靠重试。

  • 多台Worker运行。

仅依赖应用进程内的后台任务就不够了。

FastAPI 官方文档也说明,重计算或需要跨进程、跨服务器执行的工作,可以考虑 Celery 等独立任务处理系统。

所以,我们将任务持久化到 PostgreSQL。

Worker 再从数据库领取任务。

为什么第一版不引入 Redis 和 Celery?

不是因为它们不好。

而是为了让系统保持足够简单。

对于早期 ResearchOps,我们已经需要 PostgreSQL 存储任务、报告、审批和状态。

因此,可以暂时用数据库作为小规模任务队列。

这样可以减少一个基础设施组件。

但必须明确:

PostgreSQL任务队列适合受控规模的MVP,不代表它永远比专用队列或Durable Workflow系统更合适。

当任务量、吞吐、延迟和恢复需求提升时,应重新评估架构。


四、重新设计任务状态机

建议先定义任务状态,而不是先写 Runner.run()。

第一版可以采用:

                queued
                  |
                  v
                running
                  |
          +-------+-------+
          |               |
          v               v
       completed         failed

后续生产化再增加:

retry_wait
awaiting_approval
cancel_requested
cancelled
unknown_outcome

为什么第一版不一口气加所有状态?

因为每增加一个状态,就需要明确:

它由谁进入?

由谁退出?

如何保证并发安全?

服务重启后怎么办?

什么时候可以重试?

如果没有明确规则,状态越多,系统越难维护。

最小任务数据模型

CREATE TABLE research_tasks (
    id UUID PRIMARY KEY,
    owner_id UUID NOT NULL,
    topic TEXT NOT NULL,
    status TEXT NOT NULL
        CHECK (
            status IN (
                'queued',
                'running',
                'completed',
                'failed'
            )
        ),
    attempt_count INTEGER NOT NULL DEFAULT 0,
    lease_until TIMESTAMPTZ,
    worker_id TEXT,
    result JSONB,
    error_code TEXT,
    created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
    updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
);

这些字段有不同作用。

id 是任务的业务身份。

status 表示当前状态。

attempt_count 记录执行尝试次数。

lease_until 表示Worker的任务租约有效期。

worker_id 用于识别当前执行者。

result 保存结构化输出。

error_code 保存脱敏后的失败类别。

为什么要有 Lease?

假设Worker领取一个任务后崩溃。

数据库仍然记录:

status = running

如果没有额外机制,任务可能永远卡住。

Lease可以表达:

“这项任务暂时属于这个Worker,但拥有权只在某个时间内有效。”

租约过期后,系统可以安排核对和重新执行。

不过,Lease本身并不保证旧Worker已经停止。

因此,生产系统还需要Fencing Token、状态版本或其他机制,防止过期Worker继续提交结果。


五、PostgreSQL如何安全领取任务?

如果两个Worker同时查询:

SELECT *
FROM research_tasks
WHERE status = 'queued'
LIMIT 1;

它们可能读到同一个任务。

于是,两个Worker同时执行模型调用。

这就带来重复费用和重复副作用风险。

PostgreSQL提供了 FOR UPDATE SKIP LOCKED。

我们可以使用下面的方式领取任务:

WITH candidate AS (
    SELECT id
    FROM research_tasks
    WHERE status = 'queued'
    ORDER BY created_at
    FOR UPDATE SKIP LOCKED
    LIMIT 1
)
UPDATE research_tasks AS t
SET
    status = 'running',
    worker_id = $1,
    lease_until = now() + INTERVAL '5 minutes',
    attempt_count = attempt_count + 1,
    updated_at = now()
FROM candidate
WHERE t.id = candidate.id
RETURNING t.*;

这样,多个Worker同时领取任务时,可以跳过已经被其他事务锁定的队列行。

但这里有两点必须强调。

第一,这条SQL必须在事务中执行,并提交领取结果。

第二,SKIP LOCKED只负责减少领取时的锁竞争,不提供完整的任务恢复语义。

真正的可靠队列仍需要:

  • 租约续期。

  • 过期任务扫描。

  • 最大重试次数。

  • 延迟重试。

  • 死信处理。

  • 任务取消。

  • Worker失联检测。

  • 幂等结果提交。

  • 合理的队列索引。

任务领取正确,只是可靠异步执行的第一步。


六、接入真实 LLM:不要让模型随意生成最终JSON字符串

现在进入真正的模型接入。

对于研究报告,我们希望输出:

{
  "title": "AI Agent 技术研究",
  "summary": "报告摘要",
  "findings": [
    {
      "claim": "一条经过验证的事实",
      "source_url": "https://example.com"
    }
  ],
  "uncertainties": []
}

如果只要求模型:

“请严格输出JSON。”

有时仍可能出现:

  • JSON语法错误。

  • 缺少字段。

  • 字段类型不符合预期。

  • 多余解释文字。

因此,更建议使用 SDK 提供的结构化输出能力。

使用 Pydantic 定义结果类型

from pydantic import BaseModel, Field


class Finding(BaseModel):
    claim: str = Field(min_length=1)
    source_url: str


class ResearchReport(BaseModel):
    title: str = Field(min_length=1)
    summary: str = Field(min_length=1)
    findings: list[Finding]
    uncertainties: list[str]

然后建立Agent:

from agents import Agent


research_agent = Agent(
    name="ResearchOps Agent",
    instructions=(
        "你负责生成结构化研究报告。"
        "只使用已提供或实际检索到的证据。"
        "不得编造网址或事实。"
        "证据不足时明确写入uncertainties。"
        "不得执行任何发布操作。"
    ),
    output_type=ResearchReport,
)

执行:

from agents import Runner, RunConfig


async def generate_report(topic: str):
    result = await Runner.run(
        research_agent,
        topic,
        max_turns=8,
        run_config=RunConfig(
            trace_include_sensitive_data=False
        ),
    )

    report = result.final_output

    if not isinstance(report, ResearchReport):
        raise ValueError("Unexpected report type")

    return report

OpenAI Agents SDK 的 output_type 可以使用Pydantic模型,Runner.run()也支持异步执行与最大轮数限制。

但有一个很重要的事实:

结构化输出保证的是格式和类型约束,不保证内容真实。

模型即使返回一个完全合法的 source_url 字符串,也不意味着该网址真实存在,更不意味着它支持对应结论。

因此,在发布前还需要独立的证据验证。


七、一个不能省略的设计:区分“生成报告”和“研究事实”

很多演示会写成:

result = await Runner.run(
    research_agent,
    "研究2026年的最新AI新闻"
)

然后直接展示生成的报告。

但如果没有真正的搜索或资料读取工具,模型不具备可靠获取实时信息的条件。

对于 ResearchOps,我们应该把研究分成两个阶段。

第一阶段:获取证据

由可信工具完成:

  • 查询授权知识库。

  • 搜索指定来源。

  • 下载资料。

  • 记录来源URL。

  • 保存发布时间和读取时间。

  • 检查文档权限。

第二阶段:根据证据生成报告

模型只能基于提供的证据作出总结。

建议输入结构:

{
  "task": "研究Agent工程实践",
  "evidence": [
    {
      "id": "source_001",
      "title": "Official Engineering Note",
      "url": "https://example.com/article",
      "retrieved_at": "2026-11-13T08:00:00Z",
      "excerpt": "Relevant factual passage"
    }
  ]
}

模型输出则引用 source_001。

最终由业务程序检查:

  • 引用ID是否来自实际证据集合。

  • 引用是否具有可追溯来源。

  • 内容是否包含未经验证的断言。

  • 资料是否仍然有效。

这种方式比让模型直接编造或填写任意网址更容易验证。

一条核心原则

Evidence是可信系统提供的输入资源,Citation是模型选择的引用关系。

模型可以选择引用哪条证据。

但不能自行创造证据。


八、编写一个可运行的最小任务引擎

为了帮助理解后台执行、状态和故障恢复,我们先不接入真实模型。

使用 Python 标准库实现一个最小Worker。

它包含:

  • SQLite持久化任务。

  • 原子领取。

  • 独立Worker。

  • 模拟研究执行。

  • 结果存储。

  • 重复运行保护。

这样可以先验证调度逻辑,再将研究函数替换为真实 Runner.run()。

完整代码

保存为 task_engine.py:

import json
import sqlite3
import sys
import time
import uuid


DB_PATH = "research_tasks.sqlite3"


def connect():
    db = sqlite3.connect(
        DB_PATH,
        timeout=10,
        isolation_level=None,
    )

    db.row_factory = sqlite3.Row
    db.execute("PRAGMA busy_timeout=10000")

    return db


def initialize():
    with connect() as db:
        db.execute("""
            CREATE TABLE IF NOT EXISTS tasks (
                id TEXT PRIMARY KEY,
                topic TEXT NOT NULL,
                status TEXT NOT NULL,
                result_json TEXT,
                created_at REAL NOT NULL
            )
        """)


def create_task(topic):
    task_id = str(uuid.uuid4())

    with connect() as db:
        db.execute(
            """
            INSERT INTO tasks (
                id, topic, status, created_at
            )
            VALUES (?, ?, 'queued', ?)
            """,
            (task_id, topic, time.time()),
        )

    return task_id


def claim_task():
    db = connect()

    try:
        db.execute("BEGIN IMMEDIATE")

        task = db.execute("""
            SELECT *
            FROM tasks
            WHERE status = 'queued'
            ORDER BY created_at
            LIMIT 1
        """).fetchone()

        if task is None:
            db.execute("COMMIT")
            return None

        updated = db.execute(
            """
            UPDATE tasks
            SET status = 'running'
            WHERE id = ?
              AND status = 'queued'
            """,
            (task["id"],),
        )

        if updated.rowcount != 1:
            db.execute("ROLLBACK")
            return None

        db.execute("COMMIT")

        return dict(task)

    except Exception:
        if db.in_transaction:
            db.execute("ROLLBACK")
        raise

    finally:
        db.close()


def execute_research(topic):
    # 确定性模拟研究器。
    # 实际接入时替换成 LLM Agent。
    time.sleep(0.2)

    return {
        "title": f"研究报告:{topic}",
        "summary": "这是模拟生成的报告。",
        "findings": [],
        "uncertainties": [
            "当前尚未接入真实检索与模型。"
        ],
    }


def process_one():
    task = claim_task()

    if task is None:
        print("No pending task")
        return

    task_id = task["id"]

    try:
        result = execute_research(task["topic"])

        with connect() as db:
            db.execute(
                """
                UPDATE tasks
                SET status = 'completed',
                    result_json = ?
                WHERE id = ?
                  AND status = 'running'
                """,
                (json.dumps(result), task_id),
            )

        print("Completed:", task_id)

    except Exception:
        with connect() as db:
            db.execute(
                """
                UPDATE tasks
                SET status = 'failed'
                WHERE id = ?
                  AND status = 'running'
                """,
                (task_id,),
            )
        raise


def show_tasks():
    with connect() as db:
        rows = db.execute(
            """
            SELECT id, topic, status, result_json
            FROM tasks
            ORDER BY created_at
            """
        ).fetchall()

        for row in rows:
            print(dict(row))


def main():
    initialize()

    command = sys.argv[1] if len(sys.argv) > 1 else ""

    if command == "create":
        topic = " ".join(sys.argv[2:])

        if not topic.strip():
            raise SystemExit("Topic required")

        print(create_task(topic))

    elif command == "work":
        process_one()

    elif command == "list":
        show_tasks()

    else:
        print(
            "Usage:\n"
            "  python task_engine.py create 研究主题\n"
            "  python task_engine.py work\n"
            "  python task_engine.py list"
        )


if __name__ == "__main__":
    main()

运行方法

首先创建任务:

python task_engine.py create "Agent Runtime最新实践"

运行Worker:

python task_engine.py work

查询结果:

python task_engine.py list

这段代码仅依赖Python标准库。

它演示了SQLite事务领取和结果持久化。

即使启动多个Worker进程,由于领取阶段使用了 BEGIN IMMEDIATE 和状态条件更新,同一个排队任务不会被两个成功的领取事务同时获取。

但必须明确这个示例的限制

它还不是可靠任务系统。

如果进程在 running 状态下崩溃,任务不会自动回到队列。

如果旧Worker长时间运行,也没有租约和Fencing Token限制。

它没有多租户身份认证,没有运行预算,也没有取消和重试策略。

因此,只适合学习任务状态与持久化机制。

生产环境应使用前面设计的 PostgreSQL 领取策略,配合租约续期、恢复扫描和幂等操作记录。


九、怎样将模拟研究器替换成真实 Agent?

完成上面的任务引擎后,我们已经具备清晰的替换点。

原来:

def execute_research(topic):
    time.sleep(0.2)
    return {
        "title": f"研究报告:{topic}",
        "summary": "模拟结果",
        "findings": [],
        "uncertainties": [],
    }

升级后:

async def execute_research(topic):
    report = await generate_report(topic)
    return report.model_dump()

Worker则需要在适合的异步执行上下文中调用它。

例如,对于当前这个同步示例,可以在Worker主流程中使用:

import asyncio

result = asyncio.run(
    execute_research(task["topic"])
)

但不能在已经运行的事件循环内部再次使用 asyncio.run()。

对于真正的异步Worker,应该直接 await。

此外,在生产环境中不能无限等待模型调用。

建议同时设置:

  • 模型调用超时。

  • 最大Agent轮数。

  • 任务总截止时间。

  • 工具调用预算。

  • Token或成本上限。

  • 失败类别。

  • 有界重试策略。

尤其不能认为 max_turns=8 就意味着执行时间一定很短。

某一轮模型调用可能耗时很长,工具也可能卡住。

因此,模型轮数、外部调用超时和端到端任务截止时间,需要分别设计。


十、Worker并发:为什么越多不一定越快?

假设每个研究任务需要调用10次模型。

我们启动20个Worker。

理论上可以同时执行20个任务。

但这并不意味着吞吐会提高20倍。

因为外部模型服务可能存在:

  • 请求速率限制。

  • Token速率限制。

  • 并发配额。

  • 网络瓶颈。

  • 工具服务瓶颈。

如果Worker数量超过系统能够稳定处理的范围,可能出现:

请求被限流。

重试次数增加。

任务等待时间变长。

总成本反而上升。

所以生产系统要区分两个概念:

任务并发数: 同时运行多少项用户任务。

模型调用并发数: 同时向模型服务发出多少请求。

两者并不一定相同。

一个任务内部也可能包含多个模型或工具请求。

推荐的并发控制

第一版可以使用固定Worker数量和全局Semaphore。

后续再根据业务类型设置:

  • 每用户并发上限。

  • 每租户并发上限。

  • 每模型并发上限。

  • 每工具并发上限。

  • 总Token预算。

  • 优先级和排队策略。

当任务存在严格业务顺序时,还需要防止同一业务资源的操作被不同Worker并发执行。


十一、模型失败后应该怎样处理?

假设 Runner.run() 抛出异常。

不能直接:

except Exception:
    retry_forever()

应该根据失败类型处理。

失败类型 建议处理
临时限流 有界退避并遵守服务端提示
临时服务不可用 有界重试
无效输入 终止并返回可修正错误
结构化输出校验失败 限制次数重新生成或人工检查
工具权限被拒绝 停止,不自动提升权限
工具副作用结果未知 先核对外部状态
任务预算耗尽 停止或申请明确的新授权

特别需要注意:

重试整个模型Run,与重试某一次模型请求,是两种不同操作。

如果已经执行过有副作用的工具,再从头运行Agent,可能重复执行这些操作。

因此,我们应该保留业务Operation ID和工具执行记录。

对于可恢复的SDK状态,可以使用官方提供的RunState能力。

但无论使用什么框架,都不能把Checkpoint当成外部业务的Exactly-once保证。


十二、端到端验证:不要只测试模型能否回答

当系统有了真实Agent和后台任务之后,我建议建立第一套端到端验收测试。

场景一:正常完成

用户提交任务。

API返回202和Task ID。

Worker领取任务。

模型输出符合结构化类型。

验证通过。

数据库状态变成 completed。

场景二:模型超时

任务应记录明确错误状态。

不能无限运行。

是否重试由策略决定。

场景三:Worker异常退出

任务应能够在租约过期后进入安全恢复流程。

不能永久卡在 running。

场景四:用户提交重复请求

如果产品要求同一业务请求只能创建一项任务,API应支持客户端幂等键。

但“相同主题”不一定意味着重复任务。

应根据业务请求身份判断,而不是简单对主题文本去重。

场景五:模型给出不存在的引用

结构化JSON可能完全合法。

但独立引用验证必须失败。

不能自动发布。

场景六:模型尝试调用越权工具

Tool Gateway拒绝执行。

不能因为模型声称操作必要,就扩大权限。

场景七:任务执行成本超预算

系统停止执行并记录预算耗尽状态。

不能无限重试或不断创建子Agent。

场景八:重复执行具有副作用的操作

最终只应产生一次业务效果。

通过幂等记录、数据库唯一约束和真实业务状态验证实现。


十三、第一版应该记录哪些 Metrics?

当我们拥有真实模型调用和后台Worker后,就可以开始测量运行质量。

我建议先记录以下指标。

指标 说明
Task Success Rate 成功任务占比
Queue Wait Time 排队等待时间
Task Execution Time 实际执行时间
LLM Request Count 模型请求数量
Tool Call Count 工具调用数量
Input / Output Tokens 模型Token使用量
Cost per Success 每成功任务成本
Retry Rate 重试比例
Validation Failure Rate 结果验证失败比例
Stuck Task Count 超出预期仍未结束的任务数

其中,Queue Wait Time与Execution Time必须分开。

用户感受到的总延迟可能来自两个完全不同的问题。

如果队列等待很长,应检查容量、优先级和任务调度。

如果执行本身很慢,应检查模型、工具与关键路径。

不能只用一个“平均响应时间”定位所有问题。

Tracing与隐私

OpenAI Agents SDK的Tracing默认启用,而且部分Span可能包含输入、输出或工具参数。

如果处理企业内部文档,应该主动配置:

RunConfig(
    trace_include_sensitive_data=False
)

这可以减少敏感内容进入SDK Trace。

但这并不代表所有应用日志、第三方工具和自定义Exporter都会自动脱敏。

生产系统仍应建立统一的日志与遥测数据策略。


十四、什么时候需要升级到真正的 Durable Workflow?

用PostgreSQL队列表可以支持第一阶段。

但当系统出现以下需求时,架构需要升级:

任务持续数小时甚至数天。

任务包含多个需要恢复的阶段。

审批可能等待用户数天。

存在复杂外部副作用和补偿。

多种任务需要不同重试策略。

Worker重启后必须从明确检查点恢复。

这时,可以考虑 Temporal、LangGraph Durable Execution 或其他适合自身环境的持久工作流技术。

需要注意:

引入Durable Workflow,并不意味着可以放弃业务幂等。

模型或工具调用可能已经产生实际效果,但完成记录尚未持久化。

恢复时仍可能重新执行。

因此,业务操作的稳定身份、外部状态核对和幂等记录,仍然是关键组成部分。


十五、从第十篇MVP到第十一篇,真正完成了什么?

第十篇主要解决系统结构。

第十一篇开始解决真实运行。

两者的区别可以总结为:

能力 第十篇MVP 第十一篇目标
HTTP接口 有 保留
数据库存储 有 增加任务队列语义
Agent执行 确定性模拟 接入真实LLM
结果类型 普通字符串或对象 Pydantic结构化输出
任务状态 基础状态 独立Worker与领取
工具权限 基础审批设计 明确业务工具边界
故障处理 基础异常处理 分类、有界重试
可观测性 基础Trace 模型、队列、任务指标
质量控制 手动验证 建立端到端Evals

值得强调的是:

第十一篇的独立Worker示例仍然只是任务引擎教学实现。

真实LLM示例需要配置API访问权限和经过验证的模型。

而生产级Lease、Fencing、任务恢复、复杂审批及工具幂等,仍然需要按工程计划继续完成。

不应该因为我们已经能够异步调用模型,就声称整个系统具备生产级可靠性。


十六、下一步应该怎么迭代?

现在我们已经形成了一条比较清晰的工程路径。

第一阶段:可运行

FastAPI接收任务。

Worker执行Agent。

PostgreSQL存储结果。

第二阶段:可验证

结构化输出。

来源核验。

固定Evals数据集。

失败回归测试。

第三阶段:可恢复

任务Lease。

Checkpoint。

幂等。

结果不确定时的Reconciliation。

第四阶段:可运营

OpenTelemetry。

成本和延迟指标。

限流与配额。

多租户身份权限。

备份恢复与灰度发布。

这里最重要的是开发顺序:

先让一条最小业务链路跑通,再逐步强化正确性、可靠性、安全性和运营能力。

如果第一天就建立复杂的多Agent系统、多个向量数据库、Kubernetes集群和分布式工作流,却没有一套可以验证的真实任务,很容易把系统做得非常复杂,却无法证明业务价值。


结语:真正的Agent工程化,从“任务可以独立运行”开始

前十篇,我们讨论了一个真正可靠的 Agent 系统应该具备什么。

第十一篇开始,我们把这些设计逐步落实到代码。

这次最重要的三个变化是:

第一,模型调用从Web接口中独立出来。

第二,任务状态从应用内存进入持久化数据库。

第三,模型输出从自由文本变成可验证的结构化结果。

这些变化看起来没有Multi-Agent那样引人注目。

也不像最新模型发布那样容易成为技术热点。

但它们决定了一个Agent系统能不能真正交给用户使用。

当用户关闭页面时,任务仍然能够继续。

当模型失败时,系统知道该如何处理。

当结果生成之后,系统能够检查它是否符合业务要求。

当某个工具已经产生副作用时,系统不会因为简单重试而重复执行。

这些能力才是从Demo走向真实产品的第一步。

优秀模型让Agent有能力完成任务。

可靠Runtime让Agent能够持续完成任务。

可信验证体系让我们知道任务是否真正完成。

下一阶段,我们不应该急着增加更多Agent。

而应该先把这一条任务链路做到可恢复、可追踪、可验证。

因为:

生产级Agent的进步,不在于架构图越来越复杂,而在于每一项关键能力都能够被代码和测试真实证明。


【声明】本内容来自华为云开发者社区博主,不代表华为云及华为云开发者社区的观点和立场。转载时必须标注文章的来源(华为云社区)、文章链接、文章作者等基本信息,否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@huaweicloud.com
  • 点赞
  • 收藏
  • 关注作者

评论(0)

0/1000
抱歉,系统识别当前为高风险访问,暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称,即可参与社区互动!

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。