Session 01: from LLM to agent — when the model starts choosing the next step

很多人第一次接触 Agent,看到的都是一堆名词:Agent Loop、Tool Calling、Memory、Planning、MCP…… 这样很容易把 Agent 学成一张名词表。这次我们直接从一个最简单的 LLM 程序开始,然后一点点把它改造成一个真正会“自己决定下一步”的 Agent。我们这次做的还是一个内容创作 Agent。

Originally in ChineseThis article was written in Chinese. The body below is the Chinese original; the English translation is not available yet.

一、先写一个最普通的 LLM 程序

最简单的 AI 应用其实没什么神秘的:程序把用户的问题交给大模型,再把结果返回给用户。在代码里,最基本的事情就是准备消息然后调用模型。

python
from openai import OpenAI

client = OpenAI()

messages = [
    {
        "role": "system",
        "content": "你是一个公众号写作助手,负责帮助用户完成文章创作。"
    },
    {
        "role": "user",
        "content": "帮我写一篇关于 AI Agent 的文章。"
    }
]

response = client.chat.completions.create(
    model="your-model",
    messages=messages,
)

print(response.choices[0].message.content)

这里你会看到三个最基本的角色:system、user、assistant。user 是用户说的话,assistant 是模型已经产生的回答,而 system 是提前给模型设定的一套工作规则。

一个最小的 LLM 应用,可以抽象成:用户输入 → System Prompt + User Message → LLM → Assistant Response。除了消息本身,调用模型时还会遇到一些基本参数,比如 model 决定用哪个模型,temperature 影响输出的随机性,max_tokens 限制输出长度:

python
def generate(self, messages: list[Message]) -> str:
        """Send messages to the model and return its text response."""
        try:
            completion = self._client.chat.completions.create(
                model=self.model,
                messages=messages,  # type: ignore[arg-type]
                temperature=self.temperature,
                max_tokens=self.max_tokens,
            )
        except Exception as exc:  # network / provider errors surface as LLMError
            raise LLMError(str(exc)) from exc

        return completion.choices[0].message.content or ""

到这里为止,我们的程序仍然只有一个动作:用户问,模型答。变化从下一步开始。

二、普通 LLM 和 Agent,差在哪里?

如果用户说“帮我写一篇关于 AI Agent 的文章”。普通 LLM 可能直接生成文章,但一个真正的内容创作助手,它会先分析需求、再制定计划、让用户确认以后再继续。流程变成:用户提需求 → LLM 分析 → 生成文章计划 → 询问用户是否确认 → 用户修改/确认 → 继续处理 → 生成文章 → 结束。

这里有了一个很重要的变化:模型不只是“一次性回答”,它需要根据当前情况决定“下一步到底应该做什么”。我们可以先给它三个 Action:ASK_USER、WRITE_ARTICLE、FINAL_ANSWER。模型负责选择 Action,程序负责执行 Action——这就是 Agent 最基本的形态。

三、我们来写第一个 Agent

Agent 最核心的东西其实就是一个循环。最简单的逻辑是 Decision → Action → Observation → Decision → Action → Observation…… 第一次运行时 LLM 负责决定下一步,程序拿到决定以后执行,执行结果再交回 Agent,Agent 再根据新的结果做下一次决定,这就是最基本的 Agent Loop。

在真正的实现里,我们不会让模型随便返回一段文字然后程序自己猜它是什么意思,而是让模型返回结构化的 Action,例如:

json
{
  "action": "ASK_USER",
  "message": "我先生成文章计划,请你确认。"
}

这里有个很重要的边界:LLM 负责决策,程序负责验证、执行和控制。 这个原则后面会反复出现——Tool Calling 是这样,Memory 是这样,Human-in-the-loop 也是这样。

四、把它变成一个内容创作 Agent

现在给这个 Agent 一个具体任务:“帮我写一篇关于 AI Agent 的文章。” Agent 第一次可能决定 ASK_USER,返回“我先给你一个文章计划,你确认后我再继续”,程序执行 ASK_USER 等待用户输入。用户说“这个角度太普通,换一个”,这个结果重新回到 Agent,于是模型再次决定 ASK_USER,返回“可以改成从 Agent 工程实践的角度来写,你看可以吗?”。用户确认以后,Agent 再决定 WRITE_ARTICLE 按确认后的方向生成文章,文章生成后再决定 FINAL_ANSWER 表示完成。

python
MAX_ITERATIONS = 10

for step in range(MAX_ITERATIONS):
    decision = llm.decide(messages)

    action = decision["action"]

    if action == "ASK_USER":
        result = ask_user(decision["message"])

    elif action == "WRITE_ARTICLE":
        result = write_article(decision["content"])

    elif action == "FINAL_ANSWER":
        print(decision["content"])
        break

    else:
        result = f"Invalid action: {action}"

    messages.append({
        "role": "observation",
        "content": result
    })

整个过程变成:用户需求 → LLM 决策 → ASK_USER → 用户反馈 → LLM 再次决策 → WRITE_ARTICLE → 文章结果 → FINAL_ANSWER。到这里,我们已经有了一个最小 Agent。它还很笨,但已经不再是简单的“一问一答”。

五、代码能跑以后,问题马上来了

前面只是把 Agent 的基本机制跑通,但生产环境马上就会暴露出一堆工程问题:它会不会一直跑下去?LLM 返回了一个不存在的 Action 怎么办?Action 执行失败怎么办?Agent 说“完成了”真的完成了吗?它会不会一直重复同一个 Action?

5.1 这个 Loop 会不会停不下来?

假设模型一直认为自己应该继续执行,连续返回 WRITE_ARTICLE、WRITE_ARTICLE…… 如果没有终止条件,这个 Loop 理论上可以一直运行。

最简单的解决方案:限制最大执行次数,比如最多执行 10 次,这样即使模型出了问题也不会无限调用。但实际工程里通常不会只有这一层:

加 Timeout,限制 Agent 最长运行时间,比如超过 30 秒还没结束就停止;

加 Loop Detection,记录最近几次 Action,如果出现连续 SEARCH、SEARCH、SEARCH、SEARCH 就可能说明 Agent 卡住了;

加 State Change Detection,比单纯判断 Action 重复更进一步——我们真正关心的是 Agent 每执行一步以后有没有产生新的有效信息,如果每次都是 Action → Observation A → Action → Observation A,继续运行的意义就很小;

加 Budget / Cost Limit,限制 Token、调用次数或成本,防止 Agent 即使没死循环也不停调用模型。

这些方案解决不同层次的问题,共同目标都是别让 Agent 的自主循环失去控制。

5.2 LLM 返回了不存在的 Action 怎么办?

我们规定 Agent 只有 ASK_USER、WRITE_ARTICLE、FINAL_ANSWER,但 LLM 是通过生成文本工作的,它完全可能返回 {"action": "MAKE_COFFEE"}。所以程序不能因为模型提供的,就默认这个 Action 合法。最基本的办法是 Action Validation:程序维护一个合法 Action 列表,如果模型返回其他值就拒绝执行。这是一个非常重要的工程原则——LLM 的输出必须经过程序验证,不能直接进入执行层。

5.3 Action 执行失败怎么办?

假设模型决定 WRITE_ARTICLE,程序开始执行却报错了——可能是网络问题,可能是文件写入失败,也可能是外部服务暂时不可用。如果程序直接退出,那这个 Agent 的自主能力其实非常有限。更合理的流程是:LLM 决定 Action → 程序执行 → 执行失败 → 把错误信息变成 Observation → LLM 再次决定。这样 Agent 才有机会根据失败原因重新选择方案。

真正的工程系统还会继续往下做:

Retry 让临时错误自动重试;

Exponential Backoff 让重试不能无限高速进行,而是逐渐拉长间隔(1 秒 → 2 秒 → 4 秒 → 8 秒);

Error Classification 先判断错误类型,比如网络超时可以重试、参数错误重试没意义、权限错误需要人工处理;

Fallback 在主方案失败以后切换备用方案;

Recovery 从失败状态恢复,而不是整个 Agent 从头开始。

这些能力以后可以独立展开,当前版本只需要建立一个基本认识:Action 执行失败,也是 Agent 决策过程的一部分。

5.4 Agent 说“完成了”,真的完成了吗?

还有一个很容易被忽略的问题:假设模型最后说“文章已经完成”,程序就真的可以结束了吗?不一定。比如我们的要求是至少 1500 字、必须有标题、必须有 3 个小标题、不能出现某些内容,模型说完成了,并不意味着它真的满足这些要求。所以“LLM 说完成”和“任务真的完成”其实是两回事。

业界目前展出 Termination Condition → Rule-based Validation → Tool Result Validation → Evaluator / Verifier → Evaluation System。也就是说,Agent 不只是负责“生成结果”,还需要一个机制判断什么才叫完成,这也是为什么 Evaluation 最终会成为 Agent 系统里非常重要的一部分。

5.5 Agent 一直重复同一个 Action 怎么办?

这和无限循环有一点区别:无限循环关注的是 Agent 有没有一直运行下去,而重复 Action 更关注 Agent 是不是一直在做没有意义的事情,比如连续 SEARCH 或连续 WRITE_ARTICLE。最简单的办法是记录最近几次 Action,但这只是很粗糙的检测。更成熟的系统会结合 Loop Detection、State Change Detection、Step Limit、Observation Quality、Evaluator / Verifier,因为重复 Action 的根本原因可能不是 Action 本身,而是 Agent 没有获得新的信息。

六、从一个简单 Loop,开始看到真正的 Agent Engineering

现在再回头看最开始写的 Agent:Decision → Action → Observation → Decision。真正运行以后,它会逐渐变成 Decision → Validation → Action → Observation → Error Handling → Retry / Recovery → Loop Control → Termination。再往后,随着任务越来越复杂,还会出现 Tool、Tool Selection、State、Context、Memory、Planning、Evaluation、Checkpoint、Observability、Human-in-the-loop 等等。

七、第一版 Agent 到这里

至此我们做到了:用户提需求 → LLM 决策 → Action → 程序验证 → 执行 → Observation → 继续决策 → 最终结束,同时具备几个最基本的保护机制:有最大执行次数、Action 有基本验证、Action 失败以后能把错误反馈给 LLM、有明确的结束 Action、用户可以在 Agent 执行过程中介入。

下一次,我们不再给 Agent 写死几个简单 Action,而是给它真正的 Tool,让它自己决定要不要调用搜索、调用哪个 Tool、参数应该是什么、Tool 执行结果是什么、拿到结果以后下一步怎么办。


关注我,持续分享更多实用的 AI 干货。

Series navigation手搓 Agent · 28 articles
← Back to all writing
On this page