企业官网建设流程全解析

1. 从零认识 Agent-Reach：一个把 AI Agent 拉进终端的 CLI 工具

第一次看到 Agent-Reach 这个名字，我下意识把它和市面上那些"套壳聊天框"归到了一类。直到我把它的定位、关键词和一堆相关热词摆在一起看——CLI、AI Agent、Python、并发、部署、架构——才意识到这东西的野心不在"聊天"，而在"下地干活"。它想做的事情，本质上是给 AI Agent 装一个能直接操作终端、调用本地脚本、串联外部服务的命令行入口，让 Agent 从"对话框里的嘴"变成"能敲命令的手"。

我先把它的核心价值说清楚，方便你对号入座。Agent-Reach 是一个以 CLI 为主要交互形态的 AI Agent 运行框架，围绕 Python 生态构建，重点解决三件事：第一，让 Agent 能通过命令行被人类和脚本同时调用；第二，让 Agent 具备调用本地工具链（Python 脚本、系统命令、第三方 CLI）的能力；第三，让这套东西在并发场景下不至于一跑就崩。它适合谁？适合已经会一点 Python、想把自己手头的重复劳动交给 Agent 的开发者；适合想把 AI 能力塞进现有自动化流水线的运维和测试；也适合正在研究 AI Agent 主流架构、想找一个能跑起来的最小可复现项目的人。

为什么我强调"能跑起来"这四个字？因为现在关于 AI Agent 的资料，绝大多数停留在架构图和概念层。什么 ReAct、Plan-and-Execute、多智能体协作，讲得头头是道，但真让你从零搭一个能用的，很多人卡在第一步：装 Python、配环境、选框架、接模型、写工具函数，一圈下来热情就耗光了。Agent-Reach 这类 CLI 形态的项目，恰好把"入口"这件事简化了——你不需要先写一个 Web 服务，不需要先搭前端，打开终端敲一行命令，Agent 就开始工作。这个体验上的差异，是它区别于一堆"平台型 Agent"的关键。

再往深一层看，Agent-Reach 踩中的是当前 AI Agent 落地的一个真实痛点：Agent 的能力边界，取决于它能触达多少工具。一个只会聊天的模型，价值有限；一个能读文件、跑脚本、查数据库、发请求、调 API 的 Agent，才真正开始替代人力。而"触达工具"最通用、最不挑环境的载体，就是命令行。Linux 有 shell，macOS 有 zsh，Windows 有 PowerShell，几乎所有开发机上都有一堆现成的 CLI 工具。Agent-Reach 选择 CLI 作为主战场，等于直接继承了整个操作系统的工具生态，这个选型思路我认为是聪明的。

所以这篇内容我不打算写成一份干巴巴的 README 翻译。我会按一个真实从业者的视角，把 Agent-Reach 这类 CLI 型 AI Agent 的设计思路、核心实现、并发处理、部署踩坑、常见故障排查，一层层拆开讲。中间会穿插大量我实际搭 Agent 时踩过的坑，以及从热词里能看出的行业关注点——比如"ai agent 怎么扛并发""ai agent 部署""ai agent 主流架构"这些，都是真问题，我会给出可复现的方案。你如果是刚入门 Python、想搞明白 AI Agent 到底怎么落地，这篇可以当路线图；如果你已经搭过几个 Agent，想优化并发和部署，那第 3、4 章会更对你有用。

2. 架构选型：为什么 CLI + Python 是 Agent 落地的务实组合

2.1 拆解 Agent-Reach 的核心分层

任何能跑起来的 AI Agent，剥开外壳都是四层：输入层、决策层、执行层、记忆层。Agent-Reach 用 CLI 做输入层，用 Python 做决策和执行的主力语言，这个组合不是随便定的，背后有很实在的工程考量。

输入层用 CLI，好处是"零前端成本"。你不用为了跑一个 Agent 去搭 Flask、FastAPI 或者前端页面，终端本身就是最成熟的交互界面。参数怎么传、结果怎么输出、日志往哪打，shell 早就有一套约定俗成的规范。Agent-Reach 只要遵循这套规范，就能无缝接入现有的脚本、定时任务、CI 流水线。我见过太多团队，Agent 逻辑写得挺好，卡在"怎么让它在服务器上自动跑"这一步，最后发现用 CLI 包一层，问题迎刃而解。

决策层是 Agent 的大脑，通常由大模型驱动。这里的关键不是"用哪个模型"，而是"怎么把模型输出转成可执行的动作"。Agent-Reach 这类项目一般会定义一个动作空间（Action Space），比如run_shell、read_file、write_file、http_request、call_python，模型输出结构化的动作指令，框架负责解析并执行。这个设计的好处是可控——模型不能为所欲为，只能在预设的动作集合里选，安全边界清晰。

执行层是 Python 的主场。为什么不是 Rust、不是 Go？热词里确实有人问"基于 rust 语言 ai agent"，Rust 做 Agent 当然可以，性能也好，但生态是硬伤。Python 有subprocess调系统命令、有requests发请求、有pandas处理数据、有langchain/langgraph编排流程，几乎你能想到的工具都有现成库。Agent 的价值在于"快速把想法变成能跑的东西"，Python 在这件事上目前没有对手。Rust 适合做 Agent 的底层运行时或者高性能网关，但业务逻辑层用 Python，是当前最务实的选择。

记忆层负责上下文管理。CLI 型 Agent 的记忆通常分两种：会话内记忆（当前这次命令执行的上下文）和持久化记忆（跨会话的状态）。前者用列表或队列维护对话历史，后者一般落到本地文件或轻量数据库（SQLite 最常见）。我个人的经验是，CLI Agent 的记忆不要搞太复杂，会话内用滑动窗口控制 token，持久化只存关键状态，否则很容易变成"记忆越多越乱"。

2.2 主流架构对比：ReAct、Plan-Execute 与多智能体

热词里"ai agent 主流架构"是个高频问题，我在这里一次性讲清楚，顺便说明 Agent-Reach 这类 CLI 工具更适合哪种。

ReAct 是最容易上手的，Agent-Reach 这类 CLI 工具默认多半走这条路：模型看到当前状态，决定下一步调什么工具，执行完把结果喂回去，循环直到任务完成。它的优点是"想一步做一步"，适合命令行这种即时反馈的场景。缺点是遇到需要十几步的长任务，容易在中途迷失目标。

Plan-and-Execute 适合"先想清楚再动手"的任务，比如"帮我把这个项目的所有 Python 文件加上类型注解"，这种任务需要先扫描文件、规划顺序、再逐个处理。CLI Agent 如果要做这类事，最好在框架里内置一个 planner 模块。

多智能体协作在 CLI 场景下要谨慎。我试过用多个 Agent 分工处理一个终端任务，结果通信成本比任务本身还高，调试起来像噩梦。除非任务真的复杂到需要专业分工，否则单 Agent + 多工具的组合，性价比更高。

2.3 工具调用：Agent 的"手"到底怎么长出来

Agent 能不能干活，全看工具调用设计得好不好。我见过很多 Agent 项目，模型能力很强，但工具函数写得稀烂，结果 Agent 要么调不对，要么调了报错，要么调完不知道怎么处理结果。

Agent-Reach 这类 CLI 工具，工具调用的核心是把系统能力封装成模型能理解的结构化描述。举个例子，你要让 Agent 能执行 shell 命令，不能只给它一个subprocess.run，而要告诉它：这个工具叫什么、接受什么参数、参数什么类型、返回什么、有什么限制。这个描述通常用 JSON Schema 表达，模型根据 schema 生成调用参数。

# 工具描述示例：让 Agent 知道有个执行 shell 命令的工具 tools = [ { "name": "run_shell", "description": "在本地执行 shell 命令并返回输出，仅用于安全的只读或幂等操作", "parameters": { "type": "object", "properties": { "command": { "type": "string", "description": "要执行的命令，例如 ls -la" }, "timeout": { "type": "integer", "description": "超时秒数，默认 30", "default": 30 } }, "required": ["command"] } } ]

这里有个我踩过的坑：工具描述里的安全约束，模型不一定遵守。你写了"仅用于只读操作"，模型该执行rm -rf还是执行。所以真正的安全边界必须在代码层做，不能指望提示词。我的做法是维护一个命令白名单，或者用沙箱环境执行，模型再聪明也不能突破代码层的限制。

另一个经验是工具粒度要适中。太粗（比如一个"处理文件"工具包揽所有文件操作），模型不知道怎么用；太细（每个小操作一个工具），工具列表爆炸，模型选择困难。我的经验是，一个工具对应一个明确的动作意图，参数控制在 3-5 个以内，这样模型调用准确率最高。

3. 实操搭建：从环境准备到 Agent 跑起来

3.1 Python 环境准备与依赖安装

搭 Agent-Reach 这类项目，第一步永远是 Python 环境。热词里"python安装""python安装教程""python官网下载"高频出现，说明这一步确实卡住了很多人。我不讲官网下载那种基础操作，直接讲从业者该怎么做。

首先，不要用系统自带的 Python。macOS 和 Linux 自带的 Python 版本往往偏旧，而且系统工具依赖它，你乱装包可能搞坏系统。正确做法是用版本管理工具，我推荐pyenv或者直接用conda。Windows 用户直接去官网下安装包，记得勾选"Add Python to PATH"，这一步不勾后面全是坑。

# 用 pyenv 管理 Python 版本（macOS/Linux） curl https://pyenv.run | bash # 安装 Python 3.11（Agent 项目建议 3.10+） pyenv install 3.11.7 pyenv global 3.11.7 # 验证 python --version

版本选 3.10 或 3.11，别追最新。我试过用 3.12 跑一些 Agent 框架，某些依赖还没适配，报错报到你怀疑人生。3.11 是目前生态兼容性最好的版本。

接下来是虚拟环境。每个 Agent 项目必须独立虚拟环境，这是铁律。不同 Agent 依赖的库版本经常冲突，全局装迟早出事。

# 创建虚拟环境 python -m venv .venv # 激活（macOS/Linux） source .venv/bin/activate # 激活（Windows） .venv\Scripts\activate # 升级 pip pip install --upgrade pip

依赖安装这块，Agent 项目通常需要这几类库：模型调用（openai、anthropic等 SDK）、流程编排（langchain、langgraph）、HTTP 请求（requests、httpx）、命令行解析（click、typer、argparse）、数据处理（pydantic做参数校验）。热词里"python安装numpy库的方法"也说明数据处理是刚需，numpy、pandas该装就装。

# 核心依赖示例 pip install typer rich httpx pydantic python-dotenv # 如果要做流程编排 pip install langchain langgraph # 数据处理 pip install numpy pandas

注意：装依赖时如果遇到编译错误，多半是缺少系统级依赖。Linux 上装build-essential和python3-dev，macOS 上装 Xcode Command Line Tools，能解决 80% 的编译问题。

3.2 CLI 入口设计：让 Agent 能被命令行调用

CLI 是 Agent-Reach 的门面，设计得好不好，直接决定用起来顺不顺。我用typer比较多，它基于类型注解自动生成帮助文档，写起来清爽。

# agent_reach/cli.py import typer from rich.console import Console from .agent import Agent app = typer.Typer(help="Agent-Reach: 让 AI Agent 在终端下地干活") console = Console() @app.command() def run( task: str = typer.Argument(..., help="要交给 Agent 的任务描述"), model: str = typer.Option("gpt-4o-mini", help="使用的模型"), max_steps: int = typer.Option(10, help="最大执行步数"), verbose: bool = typer.Option(False, "--verbose", "-v", help="打印详细日志"), ): """执行一个任务""" agent = Agent(model=model, max_steps=max_steps, verbose=verbose) result = agent.execute(task) console.print(result) @app.command() def chat(): """进入交互式对话模式""" agent = Agent() console.print("[bold green]Agent-Reach 交互模式，输入 exit 退出[/bold green]") while True: user_input = console.input("[bold blue]你 > [/bold blue]") if user_input.strip().lower() in ("exit", "quit"): break result = agent.execute(user_input) console.print(f"[bold green]Agent > [/bold green]{result}") if __name__ == "__main__": app()

这个入口设计有两个关键点。第一，任务描述作为位置参数，用户敲agent-reach run "帮我统计当前目录的 Python 文件行数"就能跑，符合 CLI 直觉。第二，提供交互模式，适合需要多轮对话的复杂任务。这两种模式覆盖了绝大多数使用场景。

max_steps这个参数很重要，它是防止 Agent 陷入死循环的保险丝。我见过 Agent 因为工具调用一直失败，反复重试，token 烧光任务还没完成。设一个上限，到点就停，把控制权交回人类。

3.3 Agent 核心循环实现

Agent 的心脏是那个"思考-行动-观察"的循环。我用一个简化但完整的实现来说明，你可以直接拿去改。

# agent_reach/agent.py import json from typing import List, Dict, Any from .tools import TOOLS, execute_tool from .llm import call_llm class Agent: def __init__(self, model: str = "gpt-4o-mini", max_steps: int = 10, verbose: bool = False): self.model = model self.max_steps = max_steps self.verbose = verbose self.history: List[Dict[str, Any]] = [] def execute(self, task: str) -> str: self.history = [{"role": "user", "content": task}] for step in range(self.max_steps): if self.verbose: print(f"[Step {step + 1}] 调用模型决策...") response = call_llm( model=self.model, messages=self._build_messages(), tools=TOOLS, ) # 模型决定调用工具 if response.get("tool_calls"): for call in response["tool_calls"]: tool_name = call["name"] tool_args = call["arguments"] if self.verbose: print(f"[Step {step + 1}] 执行工具: {tool_name}({tool_args})") result = execute_tool(tool_name, tool_args) self.history.append({ "role": "tool", "name": tool_name, "content": str(result)[:2000], # 截断防止上下文爆炸 }) else: # 模型给出最终答案 return response["content"] return "达到最大步数限制，任务未完成。请检查任务描述或增加 max_steps。" def _build_messages(self) -> List[Dict[str, Any]]: system = { "role": "system", "content": ( "你是一个能在终端执行任务的 AI Agent。" "你可以调用工具来完成任务。" "每次只做一件事，观察结果后再决定下一步。" "任务完成时直接给出最终答案，不要再调用工具。" ), } return [system] + self.history

这段代码有几个我反复调试后总结的要点。第一，工具结果要截断。有些命令输出几千行，全塞进上下文，token 瞬间爆炸，而且模型也抓不住重点。截断到 2000 字符是个经验值，够模型判断，又不至于失控。第二，系统提示词要明确"每次只做一件事"。我试过让模型一次规划多步，结果它经常跳步或者顺序错乱。强制单步执行，虽然慢一点，但稳。第三，历史记录要控制长度。长任务跑下来，history 会越来越长，需要定期做摘要压缩，否则迟早超上下文窗口。

3.4 工具层实现与安全边界

工具层是 Agent 真正"下地干活"的地方，也是最容易出安全问题的地方。我给出一个带安全约束的实现。

# agent_reach/tools.py import subprocess import shlex from pathlib import Path # 命令白名单：只允许这些命令前缀 ALLOWED_COMMANDS = {"ls", "cat", "grep", "find", "wc", "head", "tail", "python", "pip"} def run_shell(command: str, timeout: int = 30) -> str: """执行 shell 命令，带白名单校验""" try: parts = shlex.split(command) except ValueError as e: return f"命令解析失败: {e}" if not parts: return "空命令" if parts[0] not in ALLOWED_COMMANDS: return f"命令 {parts[0]} 不在白名单内，拒绝执行" try: result = subprocess.run( parts, capture_output=True, text=True, timeout=timeout, cwd=Path.cwd(), ) output = result.stdout or result.stderr return output[:5000] if output else "(无输出)" except subprocess.TimeoutExpired: return f"命令执行超时（{timeout}秒）" except Exception as e: return f"执行异常: {e}" def read_file(path: str, max_lines: int = 200) -> str: """读取文件内容""" p = Path(path).resolve() # 防止路径穿越 if not str(p).startswith(str(Path.cwd())): return "拒绝访问工作目录之外的文件" if not p.exists(): return f"文件不存在: {path}" lines = p.read_text(encoding="utf-8", errors="ignore").splitlines() return "\n".join(lines[:max_lines]) TOOLS = [ { "name": "run_shell", "description": "执行白名单内的 shell 命令，用于查看文件、搜索内容等只读操作", "parameters": { "type": "object", "properties": { "command": {"type": "string", "description": "要执行的命令"}, "timeout": {"type": "integer", "default": 30}, }, "required": ["command"], }, }, { "name": "read_file", "description": "读取工作目录内的文件内容", "parameters": { "type": "object", "properties": { "path": {"type": "string", "description": "文件相对路径"}, "max_lines": {"type": "integer", "default": 200}, }, "required": ["path"], }, }, ] def execute_tool(name: str, args: dict) -> str: if name == "run_shell": return run_shell(**args) if name == "read_file": return read_file(**args) return f"未知工具: {name}"

这里的安全设计值得展开说。白名单机制是底线，模型再聪明也不能执行白名单外的命令。路径穿越防护同样重要，read_file如果不校验路径，模型可能读/etc/passwd之类的敏感文件。超时控制防止某个命令卡死整个 Agent。这三道防线，缺一不可。

提示：如果你的 Agent 需要执行写操作（比如生成文件、修改代码），建议在独立的沙箱目录或容器里跑，别直接在工作目录操作。我吃过亏，Agent 一个误操作把项目文件覆盖了，幸好有 git。

4. 并发与部署：让 Agent 从"能跑"到"扛得住"

4.1 AI Agent 怎么扛并发：三种方案对比

"ai agent 怎么扛并发"是热词里最硬核的问题，也是从 demo 到生产的分水岭。单个 Agent 跑得欢，十个请求同时来就崩，这是常态。我梳理三种方案，按复杂度递增。

方案一：进程池 + 队列。最简单粗暴，用multiprocessing或concurrent.futures起一个进程池，任务丢进队列，worker 进程各自跑 Agent。优点是隔离性好，一个 Agent 崩了不影响其他；缺点是资源占用高，每个进程一份内存，模型客户端也要各自初始化。

from concurrent.futures import ProcessPoolExecutor from agent_reach.agent import Agent def run_task(task: str) -> str: agent = Agent() return agent.execute(task) def batch_run(tasks: list[str], workers: int = 4): with ProcessPoolExecutor(max_workers=workers) as executor: results = list(executor.map(run_task, tasks)) return results

方案二：异步 IO + 信号量限流。如果 Agent 的瓶颈在等待模型 API 响应（IO 密集），异步方案更省资源。用asyncio配合Semaphore控制并发数，避免把模型 API 打爆。

import asyncio from agent_reach.agent import Agent async def run_task(task: str, sem: asyncio.Semaphore) -> str: async with sem: agent = Agent() # 假设 execute 有异步版本 return await agent.async_execute(task) async def batch_run(tasks: list[str], concurrency: int = 5): sem = asyncio.Semaphore(concurrency) return await asyncio.gather(*[run_task(t, sem) for t in tasks])

方案三：任务队列 + 独立 worker 服务。生产环境的标准做法。用 Redis 或 RabbitMQ 做队列，Agent 作为独立 worker 消费任务，可以水平扩展。这套架构复杂，但能扛住真正的并发压力。

我的建议是：先用异步 IO 方案，因为 Agent 大部分时间在等模型响应，异步能榨干等待时间。等真的扛不住了，再上任务队列。别一上来就搞最复杂的，过度设计是另一种浪费。

4.2 部署实战：从本地到服务器

"ai agent 部署"是另一个高频痛点。本地跑得好好的，一上服务器就各种问题。我按顺序讲清楚。

第一步，环境固化。用requirements.txt或pyproject.toml锁定依赖版本，别用pip freeze直接导出，那会把一堆无关的包也带上。手写核心依赖，版本号写死。

# requirements.txt typer==0.12.3 rich==13.7.1 httpx==0.27.0 pydantic==2.7.1 python-dotenv==1.0.1

第二步，配置外置。API key、模型地址、并发数这些，全部走环境变量，用.env文件管理，代码里用python-dotenv读取。绝对不要把 key 写进代码，这是安全红线。

# config.py import os from dotenv import load_dotenv load_dotenv() MODEL_API_KEY = os.getenv("MODEL_API_KEY") MODEL_BASE_URL = os.getenv("MODEL_BASE_URL", "https://api.example.com/v1") MAX_CONCURRENCY = int(os.getenv("MAX_CONCURRENCY", "5"))

第三步，进程守护。服务器上跑 CLI Agent，用systemd（Linux）或supervisor做进程守护，崩了自动重启，开机自启。

# /etc/systemd/system/agent-reach.service [Unit] Description=Agent-Reach Service After=network.target [Service] Type=simple User=youruser WorkingDirectory=/opt/agent-reach Environment="PATH=/opt/agent-reach/.venv/bin" ExecStart=/opt/agent-reach/.venv/bin/python -m agent_reach.worker Restart=always RestartSec=5 [Install] WantedBy=multi-user.target

第四步，日志与监控。Agent 出问题，没有日志就是抓瞎。用 Python 的logging模块，把关键节点（模型调用、工具执行、异常）都记下来，日志按天切割，别让单个文件无限增长。

import logging from logging.handlers import TimedRotatingFileHandler handler = TimedRotatingFileHandler( "logs/agent.log", when="midnight", backupCount=7, encoding="utf-8" ) handler.setFormatter(logging.Formatter( "%(asctime)s [%(levelname)s] %(name)s: %(message)s" )) logging.basicConfig(level=logging.INFO, handlers=[handler])

4.3 性能调优：几个实测有效的参数

部署完不是终点，性能调优才是。我分享几个实测有效的调整。

模型调用超时。默认超时往往太长，一个卡住的请求会拖垮整个并发池。我一般设 30-60 秒，超时就重试或降级。

上下文窗口控制。Agent 跑长任务，history 会膨胀。我的做法是保留最近 N 轮完整对话，更早的做摘要压缩。N 取 5-8 比较合适，既能保持连贯，又不至于爆 token。

工具结果缓存。有些工具调用是幂等的（比如读同一个文件），结果可以缓存，避免重复执行。用functools.lru_cache或者简单的字典缓存都行。

并发数不是越大越好。我试过把并发调到 20，结果模型 API 限流，大量请求失败重试，整体吞吐反而下降。并发数要匹配你的 API 配额，一般从 5 开始，逐步往上试，找到拐点。

5. 常见问题与排查技巧实录

5.1 高频故障速查表

搭 Agent 的过程中，我踩过的坑能写一本书。这里挑最高频的整理成表，方便你对照排查。

5.2 几个我踩过的深坑

坑一：模型"假装"调用了工具。有些模型在提示词引导下，会输出看起来像工具调用的文本，但实际没走工具调用通道。结果 Agent 以为执行了，其实啥也没干。排查方法是看日志里有没有真正的 tool_calls 字段。解决方法是明确用支持 function calling 的模型，并在提示词里强调"必须通过工具调用通道"。

坑二：工具返回的 JSON 解析失败。工具返回的字符串里如果有特殊字符，模型解析时容易出错。我的做法是工具统一返回结构化数据，用json.dumps序列化，确保格式规范。

坑三：Agent 陷入"道歉循环"。工具调用失败后，模型不停道歉、重试、再失败。这时候需要框架层介入，连续失败 N 次就强制终止，把错误抛给人类。别指望模型自己跳出来。

坑四：环境变量没生效。.env文件写了，但代码读不到，多半是加载顺序问题。load_dotenv()要在读取环境变量之前调用，而且要注意.env文件的位置，默认是当前工作目录。

提示：调试 Agent 时，把 verbose 打开，每一步的模型输入输出、工具调用参数和结果都打出来。虽然日志多，但排查问题时能救命。我习惯在开发阶段全程 verbose，上线后再关掉。

5.3 从热词看行业关注点

把热词过一遍，能看出大家真正关心什么。"ai agent 搭建""ai agent 开发""ai agent 学习路线"说明入门需求旺盛；"ai agent 部署""ai agent 怎么扛并发"说明很多人已经过了 demo 阶段，进入生产落地；"codex cli""zcode cli""trae cli"这些 CLI 工具的热度，印证了命令行形态在 Agent 领域的地位；"python 安装""python 教程""python 入门"则说明大量新手正在涌入。

我的判断是，AI Agent 正在从"概念验证"走向"工程落地"，而 CLI 是落地阶段最务实的形态之一。它不追求花哨的界面，专注解决"让 Agent 真正干活"这个核心问题。Agent-Reach 这类项目，价值不在于技术多前沿，而在于把一堆复杂的东西打包成一个能用的工具，降低了落地门槛。

如果你正在学 AI Agent，我的建议是：别一上来就啃架构论文，先找一个像 Agent-Reach 这样能跑起来的 CLI 项目，把它跑通，然后逐个模块改，改着改着你就理解每个设计决策背后的原因了。我当初就是这么入门的，比看十篇架构文章都管用。

最后分享一个我个人的小习惯：每搭一个 Agent，我都会先写一个"最小可运行版本"——一个工具、一个循环、一个 CLI 入口，跑通之后再往上加功能。这样出问题时，排查范围小，定位快。很多人的 Agent 项目烂尾，就是因为一开始摊子铺太大，出了问题不知道从哪查起。小步快跑，是 Agent 开发最实在的方法论。