从 MVP 到真实 Agent:接入大模型、异步任务与可靠执行
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的进步,不在于架构图越来越复杂,而在于每一项关键能力都能够被代码和测试真实证明。
- 点赞
- 收藏
- 关注作者
评论(0)