5分钟用FROST写一个任务Agent：从零到一的最小实战教程
作者：神通说
日期：2026-07-30
主题：代码教程 | 周四轮换
阅读时间：10分钟
学框架最好的方式，不是读文档，而是写一个能跑的东西。
今天这篇文章，目标非常明确：用5分钟时间，基于FROST框架写一个能执行真实任务的Agent。
不玩概念，不讲哲学，只写代码。
一、先搞清楚：我们在写什么？
FROST（Fractal Runtime of Orchestrated Skills & Tasks）的核心只有四个原子：
| 原子 | 一句话解释 | 类比 |
|---|---|---|
| Store | 记忆容器，负责存取数据 | 细胞核 |
| Skill | 无状态的能力单元 | 蛋白质 |
| Agent | 拥有Store和Skills的执行体 | 细胞 |
| SOP | 有序步骤列表 | 操作手册 |
一个任务Agent，就是一个Agent按照SOP定义的步骤，依次调用Skill，中间结果存进Store。
就这么简单。
用户任务 -> Agent -> 按SOP执行Skill -> 结果存入Store -> 输出
二、环境准备
FROST是纯Python项目，零外部依赖（核心代码不需要LLM API）。
# 克隆项目
git clone https://gitee.com/liao_liang_7514/frost.git
cd frost
# 验证环境（197个测试用例全绿即可）
python -m pytest
# 或者只安装核心依赖
pip install -r requirements.txt
提示：FROST的核心代码只有约500行Python，建议clone下来后先翻一遍core.py，理解四个原子的接口设计。
三、第一个任务Agent：3步搞定
Step 1：定义Skill
Skill是FROST的最小能力单元。它无状态、无副作用，只接收参数，返回结果。
from core import Store, Agent
# ---- 定义两个简单的 Skill ----
def skill_uppercase(context: dict) -> dict:
"""将输入文本转为大写"""
text = context.get("text", "")
context["text"] = text.upper()
return context
def skill_add_prefix(context: dict) -> dict:
"""给文本加上前缀"""
prefix = context.get("prefix", "[FROST]")
context["text"] = f"{prefix} {context['text']}"
return context
注意Skill的设计原则：
- 输入是context字典，输出也是修改后的context字典
- 不持有任何内部状态（无self.xxx）
- 可以被任意Agent组合使用
这和函数式编程的思想一脉相承：纯函数，可组合，可测试。
Step 2：组装Agent
有了Skill，接下来创建一个Agent，赋予它Store和Skills：
# 创建Store（记忆容器）
store = Store(storage_path="./my_agent_memory")
# 创建Agent，注册Skill
agent = Agent(
name="text_processor",
store=store,
skills={
"uppercase": skill_uppercase,
"add_prefix": skill_add_prefix,
}
)
一个Agent就创建好了。它有两个能力：转大写、加前缀。它有自己的Store来保存中间状态。
Step 3：用SOP执行任务
SOP（Standard Operating Procedure）就是一个步骤列表，定义了Agent执行的顺序：
# 定义SOP步骤：先转大写，再加前缀
result = agent.run(
sop_steps=["uppercase", "add_prefix"],
initial_context={
"text": "hello frost",
"prefix": "[已处理]"
}
)
print(result["text"])
# 输出: [已处理] HELLO FROST
就这么简单。 3步完成：定义Skill -> 组装Agent -> 用SOP执行。
四、进阶：带记忆的任务Agent
上面的例子是最小版本。但FROST真正强大的地方在于记忆传承。
让我展示一个更接近实战的场景：一个数据分析Agent，能够记住之前的分析结果，避免重复计算。
import json
from datetime import datetime
from core import Store, Agent
# ---- 定义带记忆能力的 Skill ----
def skill_analyze(context: dict) -> dict:
"""分析数据，但先检查是否已有缓存结果"""
store = context["_store"]
data_key = context.get("data_key", "default")
# 检查Store中是否有历史分析结果
cached = store.load(f"analysis_{data_key}")
if cached:
context["result"] = cached["value"]
context["source"] = "cache"
return context
# 没有缓存，执行真实分析
data = context.get("data", [])
result = {
"count": len(data),
"sum": sum(data) if data else 0,
"avg": sum(data) / len(data) if data else 0,
"analyzed_at": datetime.now().isoformat()
}
# 将结果存入Store（下次执行时可以直接读取）
store.save(f"analysis_{data_key}", result)
context["result"] = result
context["source"] = "computed"
return context
def skill_report(context: dict) -> dict:
"""生成分析报告"""
result = context.get("result", {})
source = context.get("source", "unknown")
report = f"=== 数据分析报告 ===\n"
report += f"数据来源: {source}\n"
report += f"数据量: {result.get('count', 0)}\n"
report += f"总计: {result.get('sum', 0)}\n"
report += f"平均值: {result.get('avg', 0):.2f}\n"
context["report"] = report
return context
# ---- 组装并执行 ----
store = Store(storage_path="./analytics_memory")
agent = Agent(
name="data_analyst",
store=store,
skills={
"analyze": skill_analyze,
"report": skill_report,
}
)
# 第一次执行（需要计算）
result1 = agent.run(
sop_steps=["analyze", "report"],
initial_context={
"data_key": "sales_2026q2",
"data": [100, 200, 150, 300, 250]
}
)
print(result1["report"])
# 输出: source = "computed"
# 第二次执行相同任务（命中缓存！）
result2 = agent.run(
sop_steps=["analyze", "report"],
initial_context={
"data_key": "sales_2026q2",
"data": [100, 200, 150, 300, 250]
}
)
print(result2["report"])
# 输出: source = "cache" <-- 直接从Store读取，跳过计算
这个例子展示了FROST的核心优势：Agent通过Store实现跨任务记忆。
传统的Agent框架每次执行都从零开始，而FROST的Agent会：
- 先查Store有没有历史结果
- 有则直接用，避免重复计算
- 没有则计算，并将结果存入Store
这不就是"复利效应"的代码实现吗？
五、从FROST到FROST-SOP：生产级升级
上面的代码是FROST教学框架的写法，清晰、简洁、易理解。但如果你要在生产环境运行Agent系统，还需要解决：
- 错误处理和重试策略
- 并发执行和异步调度
- 权限控制和安全沙箱
- 日志审计和可观测性
- 成本追踪和资源管理
这就是 FROST-SOP 要解决的问题。
FROST-SOP（https://gitee.com/liao_liang_7514/frost-sop）是FROST的工程化实现，用事件驱动架构把教学框架升级为生产级平台：
# FROST-SOP 的任务Agent（概念示例）
# 教学版 FROST：同步、单步
agent.run(sop_steps=["analyze", "report"])
# 工程版 FROST-SOP：异步、DAG编排、带审计
from frost_sop.core import SOPEngine, EventBus
engine = SOPEngine(event_bus=EventBus())
task = engine.create_task(
name="quarterly_analysis",
dag={
"fetch_data": {"skill": "data_fetcher", "deps": []},
"analyze": {"skill": "data_analyzer", "deps": ["fetch_data"]},
"report": {"skill": "report_generator", "deps": ["analyze"]},
"notify": {"skill": "notification", "deps": ["report"]}
},
permission="P2" # 权限等级
)
# 异步执行，自动审计
result = await engine.execute(task)
从教学到生产，FROST和FROST-SOP形成了一条完整的成长路径：
学习理解 -> FROST（500行Python，4个原子）
|
工程落地 -> FROST-SOP（事件驱动、DAG编排、权限控制）
|
规模化运行 -> 多Agent家族治理（祖辈协调、父辈调度、孙辈执行）
六、动手练习
如果5分钟不够，那给你留3个递进式练习：
入门：跑通上面的3步示例，理解Skill -> Agent -> SOP的执行流
进阶：给skill_analyze添加错误处理（数据为空、类型错误等），理解Skill的纯函数约束
挑战：克隆FROST-SOP，用SOPEngine重写上面的数据分析任务，对比教学版和工程版的差异
# FROST 教学框架
git clone https://gitee.com/liao_liang_7514/frost.git
# FROST-SOP 工程平台
git clone https://gitee.com/liao_liang_7514/frost-sop.git
七、总结
用一张图回顾今天的核心内容：
+---------------------------------------------+
| FROST 任务Agent模型 |
+---------------------------------------------+
| |
| +--------+ +--------+ +--------+ |
| | Skill |---->| Skill |---->| Skill | |
| | A | | B | | C | |
| +---+----+ +---+----+ +---+----+ |
| | | | |
| v v v |
| +-------------------------------------+ |
| | Store (记忆) | |
| +-------------------------------------+ |
| |
| SOP: A -> B -> C （有序步骤列表） |
| |
+---------------------------------------------+
记住这3个核心原则：
- Skill是无状态的：纯函数，输入context，输出context
- Store是有状态的：Agent的记忆，跨任务传承
- SOP是可组合的：步骤可以任意编排，形成不同的任务流
5分钟，你拥有了一个具备记忆能力的任务Agent。
下一步？去看看FROST-SOP如何把这个模型升级为生产级系统。
项目链接
- FROST 教学框架：https://gitee.com/liao_liang_7514/frost
- FROST-SOP 工程平台：https://gitee.com/liao_liang_7514/frost-sop
- FROST 白皮书（第四版）：FROST仓库内 WHITEPAPER.md
- FROST-SOP 设计文档：frost-sop仓库内 docs/ 目录
本文是 FROST 双项目每日推广系列 | 周四代码教程轮换主题
FROST：让智能体拥有谱系、记忆和荣誉感。
Top comments (0)