DEV Community: llimage

一个月，一个人，一个AI家族：FROST如何帮我撑起了一场训练营

llimage — Sat, 01 Aug 2026 03:24:25 +0000

一个月，一个人，一个AI家族：FROST如何帮我撑起了一场训练营

作者：神通说

日期：2026-08-01

主题：社区故事 | 周六轮换

项目：FROST + FROST-SOP

阅读时间：8分钟

今天是8月1日。

我的"破局·动态能力生长实战营"正式开营。

15个学员，4周训练，1999元早鸟价。

而整个课程运营体系，从设计到交付，只有一个"人"在干活——我，和我的AI家族。

这不是一个关于技术多牛的故事。

这是一个关于一个人如何学会信任AI的故事。

一、7月1日：一个疯狂的决定

一个月前的7月1日，我在凌晨2点做了一个决定：

"我要办一场训练营。8月1日开营。"

为什么疯狂？因为我的状态是这样的：

一个人：没有团队、没有运营、没有助教
零经验：没做过付费训练营
已有项目：同时还在推 FROST 开源项目和"起风"品牌

正常人的反应是："你疯了吗？"

但我的反应是："让FROST家族来算算，这件事能不能做。"

二、祖辈的5分钟评估

在FROST的框架里，祖辈（Ancestor）是家族的大脑——负责理解目标、拆解任务、分配资源。

当我把"办一场训练营"这个目标交给祖辈时，它的反应大致是这样的：

# FROST 祖辈任务评估（简化示意）
task = {
    "goal": "破局实战营 - 8月1日开营",
    "constraints": {
        "budget": 0,          # 零预算
        "team_size": 1,       # 只有创始人一人
        "deadline": "2026-08-01",
        "existing_projects": ["FROST", "起风"]
    }
}

# 祖辈的拆解
subtasks = ancestor.decompose(task)
# 结果：
# - 课程设计：12次课 × 4周 = 48个教学单元
# - 学员招募：渠道策略 + 文案 + 落地页
# - 运营交付：每日提醒 + 作业批改 + 答疑
# - 内容生产：课件 + 手册 + 工具包
# 总计：156项子任务

# 祖辈的决策
decision = ancestor.evaluate(subtasks)
# "可行。但需要精确排期和资源分配。"
# "建议：80%完成度即可启动，不要等100%完美。"

这条建议后来成了我最重要的执行原则：80%就上线，不要等完美。

三、家族的分工

FROST的设计哲学是"家族治理"——不是一个超级Agent干所有事，而是一群角色各司其职。

在备战实战营的一个月里，我的日常是这样的：

早上：斥候（Scout）出发

# 斥候每日例行（简化示意）
class Scout:
    def daily_patrol(self):
        # 1. 检查Gitee仓库状态
        frost_stats = self.check_repo("frost")
        frost_sop_stats = self.check_repo("frost-sop")

        # 2. 发布推广文章（三个平台）
        article = self.generate_article(theme="daily")
        self.publish_to("dev.to", article)
        self.publish_to("juejin", article)
        self.publish_to("zhihu", article)

        # 3. 收集行业情报
        trends = self.scan_trends(["AI Agent", "治理", "开源"])

        return DailyReport(stats, article, trends)

斥候的工作：每天早上自动发布推广文章，追踪行业趋势，收集竞品动态。

一个月下来，斥候在 Dev.to、掘金、知乎三个平台自动发布了30+篇推广文章，覆盖了7种主题轮换：

周一	周二	周三	周四	周五	周六	周日
FROST深度	SOP工程	双项目联动	代码教程	行业趋势	社区故事	轻量科普

这不是"设个定时任务"那么简单。每篇文章都需要：

了解当天主题应该讲什么
回顾之前的文章避免重复
结合最新的行业动态
适配不同平台的格式要求

白天：府兵（Soldier）执行

# 府兵执行模式（简化示意）
class Soldier:
    def execute(self, task_from_ancestor):
        # 收到祖辈分配的具体任务
        # 例如："创建实战营第1周课件"

        # 1. 搜索相关素材
        materials = self.search(topic="动态能力", source=["memory", "web"])

        # 2. 生成初稿
        draft = self.create(materials, format="markdown")

        # 3. 自检质量
        quality = self.review(draft, criteria=["完整性", "实用性", "可读性"])

        if quality.score >= 0.8:
            return draft  # 交付
        else:
            return self.revise(draft, quality.feedback)  # 迭代

府兵的工作：执行祖辈分配的具体任务——写课件、做手册、准备工具包。

晚上：长老（Elder）审计

# 长老审计模式（简化示意）
class Elder:
    def audit(self, day_report):
        # 审查今天所有的执行记录
        # 关注：是否偏离目标？是否有质量问题？

        issues = []
        for task in day_report.completed_tasks:
            if task.quality < threshold:
                issues.append(f"质量不达标：{task.name}")
            if task.time > estimate * 1.5:
                issues.append(f"耗时超预期：{task.name}")

        if issues:
            self.flag_issues(issues)
            self.suggest_correction(issues)

        # 沉淀教训
        for issue in issues:
            self.save_lesson(issue)

长老的工作：每天审查所有执行结果，发现问题、沉淀教训。

四、那些差点崩盘的瞬间

一个人+AI的协作，不是童话。真实情况是：

瞬间1：知乎API连续崩溃

从6月29日到7月中旬，知乎的发布API几乎每天都在报"参数解析错误"。每次我都得：

排查Cookie是否过期
尝试不同的API参数
记录失败原因
第二天重试

教训：API集成不能假设稳定。FROST-SOP后来专门加了"失败重试+降级"机制。

瞬间2：课程内容改了4版

第3周的时候，我发现课程设计太偏理论，动手环节不够。

祖辈重新评估后给出的建议是：

"砍掉30%理论内容，替换为实战练习。记住，学员来是为了'破局'，不是为了'听课'。"

我犹豫了一晚上，第二天执行了。

教训：AI的建议有时候比人更冷静。它不会因为"已经做了3周"就沉没成本。

瞬间3：完美主义陷阱

7月28日，距离开营还有3天。我还在修改课件的排版。

祖辈再次发出警告：

"当前课件完成度92%，已达到交付标准。继续优化的边际收益趋近于零。建议立即停止，转向开营准备。"

这是FROST给我上的最重要一课：80%完成度即可上线。

五、FROST-SOP在背后的角色

如果说FROST是"思想源头"，那FROST-SOP就是"思想开花结果"的地方。

在这一个月里，FROST-SOP承担了所有"工程化"的工作：

FROST-SOP 执行记录（7月）
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
✅ 每日推广文章自动发布（30+篇）
✅ 每日数据快报（Stars/Forks/阅读量追踪）
✅ 每周复盘报告自动生成
✅ FAQ文档双周维护更新
✅ 三平台API集成（Dev.to + 掘金 + 知乎）
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

FROST-SOP的核心价值不是"自动化"——而是让自动化变得可维护。

当知乎API崩溃时，SOP告诉我崩溃的原因和恢复路径。

当掘金需要tag_ids时，SOP记录了正确的参数组合。

当Dev.to返回403时，SOP标记了问题但没有阻塞其他平台。

这就是"工程化"的意义：不是让一切完美运行，而是让一切失败都可恢复。

六、今天的开营

8月1日，15个学员正式入营。

他们不知道的是，在他们看不到的地方：

一个AI斥候刚刚完成了今天的推广文章发布
一个AI长老刚刚审计了昨天的课件质量
一个AI府兵刚刚准备好了第一周的欢迎材料
一个AI祖辈刚刚确认了未来4周的执行计划

而我，作为这个家族的"主人"，终于可以松一口气说：

"我做到了。一个人，一个月，一个AI家族。"

写在最后：给同样是一个人的人

如果你也是一个人在战斗——无论是独立开发者、自由职业者、还是一人公司创始人——我想说的是：

AI不是来替代你的，是来成为你的家族的。

FROST的设计初衷不是"让AI做所有事"，而是"让一个人拥有一个团队"。

祖辈帮你思考战略
斥候帮你收集情报
府兵帮你执行任务
长老帮你审计质量

你不需要懂代码（我自己就是IT小白），你需要的只是：

明确你的目标
信任你的AI家族
在关键节点做决策

今天是8月1日。破局实战营正式开营。

这也是FROST家族从"开源项目"走向"真实战场"的第一天。

如果你也想拥有一个AI家族，不妨从这里开始：

🔗 FROST教学框架：https://gitee.com/liao_liang_7514/frost
🔗 FROST-SOP工程平台：https://gitee.com/liao_liang_7514/frost-sop

一个人，也可以是一支军队。

本文是FROST双项目每日推广系列的一部分。每天一篇，从不同视角分享FROST的故事。

如果觉得有帮助，欢迎 Star ⭐ 支持一下开源项目。

从"造Agent"到"管Agent"：2026年7月，AI Agent行业正在经历什么？

llimage — Fri, 31 Jul 2026 03:26:16 +0000

从"造Agent"到"管Agent"：2026年7月，AI Agent行业正在经历什么？

作者：神通说

日期：2026-07-31

主题：行业趋势 | 周五轮换

项目：FROST + FROST-SOP

阅读时间：12分钟

2026年上半年，我们都在讨论"怎么造一个Agent"。

2026年下半年，行业开始追问："怎么管住一群Agent？"

这个转变，在7月加速到令人窒息。

一、三件事，同一个信号

过去两周，三件看似不相关的事情同时发生：

7月15日，中国正式实施全球首个国家级AI Agent监管框架——《智能Agent创新应用标准化实施意见》。所有在中国部署的Agent，必须按三级决策权限分类才能"上岗"。

7月28日，Snowflake在Black Hat 2026发布Cortex AI Gateway——一个专门解决"Agent身份管理"的基础设施层产品。1Password、Okta、SailPoint等六大安全厂商同步宣布集成。

7月28日，Bain发布报告，标题开门见山："Agentic AI has crossed a threshold that existing governance cannot handle"（Agentic AI已突破现有治理能力边界）。

三件事的共同指向：Agent治理不再是学术话题，而是产业基础设施。

二、数字说话：Agent的"燃料消耗"已经到了什么量级？

要理解治理为什么突然紧迫，先看一组数字。

OpenAI 2025年企业报告披露：其企业客户平均每家机构的API推理Token消耗，一年内增长约320倍。到2026年4月，OpenAI的API处理规模已超过每分钟150亿Token。

36氪在7月29日的分析更直接：

"在部分长链、复杂任务中，Agent的Token消耗可能比传统聊天场景高出百倍、千倍。"

这意味着什么？

Agent不再是"偶尔问一下AI"，而是"持续不断地执行任务"。 当Agent从对话式走向执行式，它带来的风险维度也彻底改变了——不再是"说错话"，而是"做错事"。

一个读取数据库的Agent，一次提示词注入攻击，可能导致不可逆的数据泄露。

一个拥有文件写入权限的Agent，一个错误的决策链，可能覆盖关键业务文件。

一个能发送邮件的Agent，被恶意利用后，可以冒充企业身份发起钓鱼攻击。

能力边界突破的瞬间，治理就变成了刚需。

三、中国的解法：三级决策权限分类

中国7月15日生效的监管框架，核心设计非常清晰：

级别	定义	典型场景
Tier 1	仅人类可执行，不可代理	签署合同、转移资金
Tier 2	Agent提议，人类批准后执行	发送外部邮件、修改配置
Tier 3	在授权范围内自主执行，人类可随时干预	文档摘要、自动监控响应

这个分类的精髓不在于"分了几级"，而在于它要求每个Agent在设计阶段就必须明确自己的决策边界。

正如国际分析机构的判断：

"Operators who designed their agents without formal decision-authorisation structures now face retrofit compliance costs. The practical lesson is not to comply with China's rules specifically, but to adopt tiered autonomy architecture as the default design pattern for any agent deployment, anywhere."

（没有在正式决策授权结构下设计Agent的运营者，现在面临改造合规成本。实际教训不是要遵守中国的具体规则，而是将分层自治架构作为任何地方Agent部署的默认设计模式。）

换句话说：分层自治不是中国特色，而是全球Agent工程的下一个标配。

四、基础设施层的响应：Agent身份与治理工具链

监管只是"外驱力"。真正的产业变革，来自基础设施层的自我进化。

4.1 Agent身份管理成为刚需

Snowflake的Cortex AI Gateway做了一件事：给每个Agent一个独立的系统身份。

这不是一个锦上添花的功能。当企业运营数百个Agent时，审计日志里如果只记录"人类A的操作"，你根本无法追溯是哪个Agent、基于什么模型、在什么权限下执行了某个动作。

Cortex AI Gateway的核心控制维度：

- 模型访问治理：哪些团队可以用哪些模型，成本上限是多少
- 工具/MCP访问：100+ MCP服务器统一接入，单端点管控
- Agent身份：独立于部署者，审计日志精确到Agent级别
- 成本控制：AI支出归属到具体团队、Agent、工作负载

六大身份管理厂商（1Password、Aembit、Cyera、Linx Security、Okta、SailPoint、Saviynt）同步宣布集成——这说明身份管理行业已经形成共识：Agent身份是下一个核心战场。

4.2 微软的确定性治理路线

微软在4月开源的Agent Governance Toolkit（AGT）走了另一条路：

"与其让模型'不太可能'做坏事，不如让它在结构上'不可能'做坏事。"

这个区别是范式级的。当前大多数AI Agent安全方案本质上是System Prompt + RLHF对齐——在"劝说"模型遵守规矩。但ICLR 2025的论文数据已经证明：对GPT-4o、Claude 3、Llama-3使用自适应攻击，越狱成功率可达100%。

AGT的选择是：在模型表达"意图"之后、动作真正执行之前，用确定性的应用层代码拦截每一次工具调用、每一条消息发送。被拦截的操作不是"不大可能发生"，而是物理上不会发生。

4.3 FROST的治理视角

这正是FROST框架从第一天就在思考的问题。

FROST的五维元模型（Weapon/任务/事件/平台/规则）中，"规则"维度从设计之初就承担了这个职责——不是事后补救，而是在Agent的基因里嵌入治理逻辑：

# FROST的治理思路：在SOP定义阶段就绑定决策权限
class GovernedSOP(SOP):
    """带治理属性的SOP：每个步骤都有明确的决策权限"""

    steps = [
        Step(
            skill=analyze_data,
            decision_tier=Tier.AUTONOMOUS,     # 数据分析：自主执行
        ),
        Step(
            skill=generate_report,
            decision_tier=Tier.AUTONOMOUS,     # 生成报告：自主执行
        ),
        Step(
            skill=send_email,
            decision_tier=Tier.HUMAN_APPROVE,  # 发送邮件：需人类批准
        ),
    ]

这不是对监管的被动响应，而是Agent工程的本征需求。当你的Agent家族从1个增长到10个、100个，没有内建的治理机制，混乱只是时间问题。

五、行业图谱：2026年7月的Agent生态全景

让我们拉远视角，看看整个Agent开源生态正在发生什么。

根据7月27日更新的《2026年AI开发者必备：Agent开源生态图谱》，几个关键变化：

Agent Skills生态爆发

obra/superpowers 单项目258k Stars
三大Skills仓库单日合计涨星近50万
"谁做出App Store for AI Skills，谁就可能定义下一个分发入口"

MCP生态规模

GitHub上MCP仓库超15,900个
官方Registry登记Server近10,000个
SDK月下载9,700万次

巨头整合加速

Microsoft Agent Framework 1.0发布（Semantic Kernel + AutoGen正式合并）
xAI的Grok Build正式开源（7月14日）
GLM-5.2首次在agentic coding上击败GPT-5和Claude

这些数据的潜台词是：Agent的"造"已经高度成熟，行业的重心正在向"管"迁移。

六、从"造"到"管"的迁移路径

结合以上趋势，2026年下半年Agent工程的关键命题正在清晰化：

6.1 治理前置（Governance by Design）

不是先建Agent再补治理，而是在架构设计阶段就把治理编入DNA。

这意味着：

每个Skill定义时就要声明权限边界
每个SOP编排时就要标注决策层级
每个Agent实例化时就要绑定身份和审计策略

6.2 标准化治理协议

就像HTTP之于Web、SQL之于数据库，Agent治理也需要标准协议。

中国的三级分类是一个起点。新加坡在达沃斯发布的《智能体AI治理示范框架》提供了另一个参考。微软AGT的OPA/Cedar策略引擎走了技术实现路线。

最终的方向是：治理策略可声明、可移植、可审计、可执行。

6.3 从单体治理到家族治理

当Agent以"家族"形态运行时（一个主Agent协调多个子Agent），治理的粒度从"单个Agent的行为约束"上升到"Agent家族的协作规则"。

这正是FROST的核心定位——不是一个Agent框架，而是Agent家族的治理框架。

FROST 家族治理模型
├── 祖辈（主Agent）：全局编排，战略决策
│   ├── 父辈（中层Agent）：领域专家，承上启下
│   │   ├── 子辈（执行Agent）：具体任务执行
│   │   └── 子辈（执行Agent）：具体任务执行
│   └── 父辈（中层Agent）：领域专家
│       └── ...
└── 治理规则：贯穿全族的记忆、权限、审计体系

七、FROST + FROST-SOP：治理理念的工程化落地

理念的领先不等于工程的落地。FROST的治理理念，正在通过FROST-SOP工程平台转化为可执行的代码。

当前进展

FROST（教学框架）

五维元模型V5.0稳定版
197个测试用例全覆盖
家族治理模型V1.0已确认
Gitee：https://gitee.com/liao_liang_7514/frost

FROST-SOP（工程平台）

执行引擎防盲飞机制
Skill系统标准化设计
初始化流水线V6.1.0
Gitee：https://gitee.com/liao_liang_7514/frost-sop

下一步

8月1日，破局·动态能力生长实战营正式开营。FROST将作为第一个实战案例，在15位学员的真实场景中验证"治理前置"的理念是否真的能降低Agent工程的复杂度。

这不是一次营销行为，而是一次公开造物——培训系统设计的过程本身，就是FROST最好的Demo。

结语：治理不是刹车，是油门

Bain报告里有一句话，我觉得可以当作2026年下半年Agent行业的注脚：

"The organizations moving fastest treat governance as the enabler of scale, not the brake."

（走得最快的组织，把治理视为规模化的推动力，而不是刹车片。）

当你只有一个Agent时，治理是多余的。

当你有十个Agent时，治理是必要的。

当你有上百个Agent组成的家族时，治理是生死线。

2026年7月，行业集体走到了这个拐点。

FROST选择在这个时间点，把"治理"写进每一行代码。不是因为我们预见到了监管的到来，而是因为我们相信：好的架构，天然就是可治理的。

📌 FROST项目地址：https://gitee.com/liao_liang_7514/frost

📌 FROST-SOP项目地址：https://gitee.com/liao_liang_7514/frost-sop

📌 如果觉得有启发，欢迎Star支持一下，你的每一个Star都是我们持续开源的动力。

参考资料：

中国《智能Agent创新应用标准化实施意见》（2026年7月15日生效）
Bain: Agentic AI Governance, Risk, and Controls for Business Leaders（2026-07-28）
Snowflake Cortex AI Gateway @ Black Hat 2026（2026-07-28）
36氪：《下半年，垂直Agent先下牌桌？》（2026-07-29）
2026年AI开发者必备：Agent开源生态图谱（2026-07-27）

5分钟用FROST写一个任务Agent：从零到一的最小实战教程

llimage — Thu, 30 Jul 2026 03:26:18 +0000

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：让智能体拥有谱系、记忆和荣誉感。

FROST的复利效应：为什么你的AI Agent需要一本知识账本？

llimage — Wed, 29 Jul 2026 03:26:50 +0000

FROST的复利效应：为什么你的AI Agent需要一本"知识账本"？

作者：神通说

日期：2026-07-29

主题：双项目联动 | 周三轮换

阅读时间：10分钟

一个灵魂拷问

你的AI Agent，每次执行完任务后，学到了什么？

如果你的回答是"什么都没学到"——恭喜你，你发现了99%的Agent框架都回避的问题。

Agent执行完任务，经验去哪了？
下一次执行类似任务，能比这次做得更好吗？
如果一个Agent"退休"了，它积累的能力能传给下一代吗？

这三个问题，就是FROST和FROST-SOP这对双生子项目要解决的核心命题。

一、Agent的"知识失忆症"

让我先讲一个真实场景。

昨天，我的Agent帮我完成了一个数据分析任务——清洗3万道题目的知识点映射。它花了整整3个小时，尝试了3种算法，最终找到了一个98.7%成功率的方案。

今天，我让它做一个类似的任务——清洗另一个数据集的知识点映射。

你猜怎么着？它从零开始。之前踩过的坑、尝试过的算法、最终的最优方案——全部清零。

这不是智能，这是失忆。

传统的Agent框架把每次执行都当作"一次性消费品"：执行→输出→丢弃。Agent像一个永远在新公司第一天上班的员工，每天都在重复学习昨天的教训。

这就像你每天醒来，发现银行卡余额归零了。不管昨天赚了多少钱，今天都从零开始。

你永远不会变富。

二、复利效应：知识也可以"利滚利"

爱因斯坦说过（不管他有没有真的说过）：

复利是世界第八大奇迹。理解它的人赚取它，不理解的人支付它。

在金融世界，复利的核心很简单：今天的收益，成为明天的本金。

FROST的设计哲学，就是把这种"复利效应"引入Agent系统。

FROST的"知识账本"：Store + Skill + 宪法

FROST（Fractal Runtime of Orchestrated Skills & Tasks）用三个核心机制实现Agent的知识复利：

1. Store——知识账户

每个Agent都有一个Store（记忆容器），类似于一个"知识银行账户"。每次任务执行的结果、学到的经验、发现的规律，都会存入Store。

from frost.core import Store, Agent

# 创建Agent的记忆账户
store = Store(config={
    "backend": "persistent",  # 持久化存储，不会因重启丢失
    "namespace": "data_analyst"
})

# Agent完成任务后，自动存储经验
store.save("kp_mapping_strategy", {
    "algorithm": "embedding_semantic_match",
    "success_rate": 0.987,
    "failed_cases": ["模糊概念", "跨学科交叉"],
    "lesson": "优先使用Embedding语义匹配，关键词匹配作为降级方案",
    "timestamp": "2026-07-28T15:30:00+08:00"
})

下次执行类似任务时，Agent不是从零开始，而是先查"账"：

# 新任务开始时，先查历史经验
previous_strategy = store.load("kp_mapping_strategy")

if previous_strategy:
    # 站在"前任"的肩膀上
    print(f"历史成功率: {previous_strategy['success_rate']}")
    print(f"避坑指南: {previous_strategy['lesson']}")
    # 直接使用已验证的策略，而不是重新摸索

2. Skill——能力资产化

在FROST中，Skill不是临时的函数调用，而是可复用、可传承的能力资产。

一个Skill被创建后，它就成为了Agent家族的"固定资产"。任何后代Agent都可以直接使用，不需要重新发明轮子。

from frost.core import skill

@skill(
    name="knowledge_point_mapping",
    version="1.2.0",
    description="将题目映射到知识点体系",
    inputs={"questions": list, "kp_tree": dict},
    outputs={"mapped": list, "success_rate": float}
)
def map_questions_to_kp(context):
    """知识点映射Skill - 经过3次迭代优化"""
    # v1: 关键词匹配 -> 成功率72%
    # v2: TF-IDF语义 -> 成功率89%
    # v3: Embedding匹配 -> 成功率98.7%

    strategy = context.store.load("kp_mapping_strategy")
    if strategy and strategy["success_rate"] > 0.9:
        # 直接复用已验证的策略
        return embedding_match(context, strategy)
    else:
        # 降级到基础方案
        return keyword_match(context)

注意Skill的元数据：版本号、输入输出定义、描述。这不是装饰——这让它变成了一个可搜索、可组合、可审计的能力单元。

3. 宪法——知识的"利息规则"

FROST最独特的设计：宪法（Constitution）。

宪法定义了"知识如何流转"的规则。比如：

什么经验值得存入Store？（不是所有执行结果都有价值）
Skill在什么条件下可以升级版本？（避免不成熟的经验污染能力库）
知识在Agent之间如何传承？（父子Agent的记忆传递规则）

from frost.core import Constitution

# 定义知识流转规则
constitution = Constitution({
    "memory_policy": {
        "store_threshold": 0.8,  # 成功率>80%的经验才值得存储
        "retention_days": 90,    # 经验保留90天
        "inheritance": "full"    # 完整传承给子Agent
    },
    "skill_evolution": {
        "min_iterations": 3,     # 至少迭代3次才固化为Skill
        "max_version_bump": "minor"  # 单次最多小版本升级
    },
    "knowledge_sharing": {
        "scope": "family",       # 家族内共享
        "cross_family": "review_required"  # 跨家族需要审计
    }
})

这就是"复利规则"——定义了什么知识值得积累、如何积累、如何传递。

三、从理论到工程：FROST-SOP的"知识工厂"

FROST用500行代码证明了"Agent知识复利"的可能性。但理论和工程之间，还有一条巨大的鸿沟。

FROST-SOP就是跨越这条鸿沟的工程平台。

如果说FROST是"知识复利"的设计图，FROST-SOP就是让复利真正运转起来的知识工厂。

SOP Store：生产级知识账户

FROST-SOP将FROST的Store概念升级为生产级实现：

from frost_sop.store import SOPStore

# 生产级Store: 支持持久化、版本控制、并发安全
store = SOPStore(
    backend="sqlite",  # 或 PostgreSQL, Redis
    config={
        "versioning": True,      # 每次修改保留历史版本
        "concurrent_safe": True, # 多Agent并发安全
        "audit_log": True,       # 所有操作留痕
        "backup_interval": 3600  # 每小时自动备份
    }
)

# 写入知识 - 自动版本化
store.put("data_cleaning_pipeline", {
    "steps": ["去重", "标准化", "异常检测", "知识点映射"],
    "total_records": 374000,
    "success_rate": 0.987,
    "last_updated": "2026-07-28"
})

# 查看历史版本 - 知识的"时光机"
versions = store.history("data_cleaning_pipeline")
for v in versions:
    print(f"v{v.version}: {v.timestamp} - {v.change_summary}")
# v1.0: 2026-07-26 - 初始化，关键词匹配
# v1.1: 2026-07-27 - 升级TF-IDF
# v1.2: 2026-07-28 - 升级Embedding，成功率98.7%

Skill Registry：能力资产市场

FROST-SOP的Skill Registry让能力资产真正"流通"起来：

from frost_sop.registry import SkillRegistry

registry = SkillRegistry()

# 注册一个经过验证的Skill
registry.register(
    skill_id="kp_mapping_v3",
    skill=map_questions_to_kp,
    metadata={
        "author": "data_analyst_agent",
        "tested_iterations": 5,
        "avg_success_rate": 0.987,
        "compatible_inputs": ["math_questions", "physics_questions"],
        "dependencies": ["embedding_service", "kp_tree_v2"]
    }
)

# 其他Agent可以发现和使用这个Skill
available = registry.search(
    capability="knowledge_mapping",
    min_success_rate=0.95
)
# -> 找到 kp_mapping_v3, 成功率98.7%

这就像一个"能力市场"——Agent们可以发布自己积累的Skill，也可以搜索和使用别人积累的Skill。知识不再是一个Agent的私有财产，而是整个家族的公共资产。

EventBus：知识的"高速公路"

FROST-SOP的AsyncEventBus架构，让知识在Agent之间高速流转：

from frost_sop.event import AsyncEventBus

bus = AsyncEventBus()

# Agent A完成任务，发布"经验事件"
@bus.on("task.completed")
async def on_task_done(event):
    if event.success_rate > 0.8:
        # 高成功率 -> 自动存入知识库
        await store.put(
            f"experience/{event.task_type}",
            event.experience
        )
        # 通知其他Agent
        await bus.emit("knowledge.updated", {
            "type": event.task_type,
            "new_skill": event.skill_name,
            "success_rate": event.success_rate
        })

# Agent B订阅"知识更新"事件，自动获取新能力
@bus.on("knowledge.updated")
async def on_knowledge_update(event):
    # 自动下载并安装新Skill
    new_skill = await registry.download(event["new_skill"])
    agent.install_skill(new_skill)
    print(f"获得新能力: {event['new_skill']}")

这就是知识的高速公路——一个Agent学到的东西，可以通过事件总线，自动传播给整个Agent家族。

四、真实案例：37.4万道题目的知识复利

让我用一个真实案例来说明"知识复利"的威力。

背景

我在做一个教育项目（DeepTutor），需要将37.4万道题目映射到知识点体系。这是一个典型的"需要不断迭代优化"的任务。

用FROST+FROST-SOP的方式

第一周：基础建设

# Day 1: 创建知识点映射Skill v1
@skill(name="kp_mapping", version="1.0.0")
def kp_mapping_v1(context):
    """第一版 - 关键词匹配"""
    results = []
    for question in context.questions:
        matched = keyword_search(question.text, context.kp_tree)
        results.append({"question": question, "kp": matched})
    return results

# 成功率: 72%
# 经验存入Store
store.save("kp_mapping_experience", {
    "version": "1.0.0",
    "success_rate": 0.72,
    "failure_pattern": "同义词无法识别",
    "next_step": "引入语义相似度"
})

第二周：迭代优化

# Day 8: 基于上周经验，升级到v2
experience = store.load("kp_mapping_experience")

@skill(name="kp_mapping", version="2.0.0")
def kp_mapping_v2(context):
    """第二版 - TF-IDF语义匹配"""
    # 利用上周的经验，直接跳过已知的坑
    tfidf_matrix = build_tfidf(context.kp_tree)

    results = []
    for question in context.questions:
        scored = tfidf_search(question.text, tfidf_matrix, top_k=3)
        results.append({"question": question, "candidates": scored})
    return results

# 成功率: 89% -> 提升了17个百分点

第三周：突破瓶颈

# Day 15: 再次基于累积经验，升级到v3

@skill(name="kp_mapping", version="3.0.0")
def kp_mapping_v3(context):
    """第三版 - Embedding语义匹配 + 学科上下文"""
    # 站在前两版的肩膀上
    embeddings = load_embeddings(context.kp_tree)

    results = []
    for question in context.questions:
        # 先识别学科上下文(v2的经验中学到的)
        subject = detect_subject(question.text)
        # 在对应学科的Embedding空间中搜索
        matched = embedding_search(
            question.text, embeddings[subject], 
            threshold=0.85
        )
        results.append({"question": question, "kp": matched})
    return results

# 成功率: 98.7% -> 又提升了近10个百分点!

复利的力量

看看这个过程：

版本	成功率	关键改进	来源
v1.0	72%	关键词匹配	从零开始
v2.0	89%	TF-IDF语义	v1的失败经验
v3.0	98.7%	Embedding+学科上下文	v1+v2的累积经验

如果每次从零开始，我可能需要：

第1次：摸索到72%
第2次：重新踩坑，又摸索到72%，然后才到89%
第3次：再重新来一遍……

但有了"知识账本"，每一次迭代都站在前几次的肩膀上。72% -> 89% -> 98.7%，这不是线性增长，这是复利增长。

而这一切的基础，就是FROST的Store + Skill + Constitution三件套，加上FROST-SOP的SOP Store + Skill Registry + EventBus工程化实现。

五、你的Agent需要什么样的"知识账本"？

如果你也想让你的Agent系统拥有"知识复利"能力，这里有几个关键设计原则：

1. 经验要自动沉淀

不要让Agent"做完就忘"。每次任务完成后，自动提取经验、评估质量、决定是否入库。

# FROST-SOP的自动经验沉淀机制
@bus.on("task.completed")
async def auto_experience_extraction(event):
    experience = {
        "task_type": event.task_type,
        "inputs_summary": summarize(event.inputs),
        "outputs_summary": summarize(event.outputs),
        "success_rate": event.success_rate,
        "anomalies": detect_anomalies(event.logs),
        "timestamp": now()
    }

    # 自动评估质量
    if experience["success_rate"] > constitution["store_threshold"]:
        await store.put(
            f"experience/{event.task_type}/{event.timestamp}",
            experience
        )

2. 能力要可组合

单个Skill的价值有限，但Skill之间的组合可以创造指数级价值。

# FROST-SOP的Skill组合
from frost_sop.composer import SkillComposer

composer = SkillComposer()

# 组合多个Skill为一个工作流
workflow = composer.compose([
    "data_cleaner_v2",      # 数据清洗
    "kp_mapping_v3",        # 知识点映射(复利产物)
    "quality_checker_v1",   # 质量检查
    "report_generator_v2"   # 报告生成
])

# 这个工作流本身也变成了一个可复用的Skill
composer.save(workflow, name="full_pipeline_v1")

3. 知识要有"保质期"

不是所有经验都永远有效。市场在变、数据在变、规则在变。FROST的Constitution机制让你可以定义知识的"保质期"：

constitution = Constitution({
    "memory_policy": {
        "retention_days": 90,        # 经验保留90天
        "decay_function": "exponential",  # 指数衰减
        "refresh_on_use": True       # 被使用时续期
    }
})

写在最后

回到开头的三个问题：

Agent执行完任务，经验去哪了？

下一次执行类似任务，能比这次做得更好吗？

如果一个Agent"退休"了，它积累的能力能传给下一代吗？

FROST的答案是：经验存入Store，能力固化为Skill，传承依靠宪法。

FROST-SOP的答案是：把这些理论变成生产级工程实现，让知识复利真正跑起来。

在这个体系里，Agent不是"用完即弃"的工具，而是"越用越聪明"的伙伴。每一次执行都是一次存款，每一个Skill都是一笔资产，每一次传承都是一次复利。

你的Agent，值得拥有自己的知识账本。

项目地址

FROST(教学框架): https://gitee.com/liao_liang_7514/frost
FROST-SOP(工程平台): https://gitee.com/liao_liang_7514/frost-sop

FROST 是思想源头，FROST-SOP 是思想开花结果。

细胞会死，但谱系会存续。Agent会消亡，但宪法会传承。资产会永存。

如果这篇文章让你重新思考了"Agent的知识管理"，欢迎点赞、收藏、关注。每周三，我们聊聊FROST双项目的联动实践。

FROST-SOP 工程实践：从异步事件驱动到生产级 Agent 编排

llimage — Tue, 28 Jul 2026 03:24:24 +0000

FROST-SOP 工程实践：从异步事件驱动到生产级 Agent 编排

前言

在上一篇文章中，我们探讨了 FROST 教学框架的核心思想——五维元模型。今天，让我们深入 FROST 的工程化分支 FROST-SOP，看看如何将理论框架落地为生产可用的 Agent 编排系统。

如果说 FROST 是"理解 Agent 本质"的教科书，那 FROST-SOP 就是"构建 Agent 系统"的工具箱。

一、为什么需要 FROST-SOP？

FROST 教学框架用 ~500 行代码揭示了 Agent 的本质，但教学代码与生产代码之间存在巨大鸿沟：

问题	FROST（教学）	FROST-SOP（工程）
错误处理	简单 try-catch	完整异常层级 + 重试策略
状态管理	内存变量	SOP Store 持久化存储
并发控制	同步阻塞	AsyncEventBus 异步驱动
权限控制	无	P0-P4 五级权限体系
可观测性	print 调试	完整日志 + 审计追溯

FROST-SOP 正是为了解决这个鸿沟而诞生的。

二、核心架构：AsyncEventBus 事件驱动

FROST-SOP V3.0 采用 AsyncEventBus 架构，这是区别于 FROST 同步管道架构的关键差异。

2.1 为什么选择事件驱动？

传统的同步调用存在耦合问题：

Agent A → 调用 → Agent B → 调用 → Agent C
              ↓
           如果 B 挂了？

事件驱动的解耦优势：

EventBus.publish("task.completed", data)
     ↓              ↓              ↓
  Listener A     Listener B     Listener C

任何一个 Agent 宕机都不会影响其他 Agent，事件会被缓存、重试、审计。

2.2 核心事件类型

class EventType(Enum):
    # 任务生命周期
    TASK_CREATED = "task.created"
    TASK_ASSIGNED = "task.assigned"
    TASK_COMPLETED = "task.completed"
    TASK_FAILED = "task.failed"

    # Agent 协作
    AGENT_REGISTERED = "agent.registered"
    AGENT_HEARTBEAT = "agent.heartbeat"

    # SOP 执行
    SOP_LOADED = "sop.loaded"
    SOP_STEP_EXECUTED = "sop.step.executed"
    SOP_VERSION_CHANGED = "sop.version.changed"

三、四大核心组件

3.1 SOP Store（持久化存储）

SOP Store 负责存储和管理所有 SOP 流程定义，支持版本控制和审计追溯。

3.2 Skill Registry（原子能力注册表）

Skill 是 FROST-SOP 中的最小执行单元，类似函数但带有元数据。

3.3 Agent Orchestrator（智能体编排器）

Orchestrator 负责将多个 Skill 组装为可执行的 Agent。

3.4 AsyncEventBus（异步事件总线）

这是整个系统的中枢神经。

四、P0-P4 五级权限体系

FROST-SOP 实现了企业级的权限控制，这是从"玩具"到"生产工具"的关键跨越。

五、19 个内置 Skill

FROST-SOP 预置了 19 个开箱即用的 Skill，覆盖任务分解、SOP搜索、Agent组装、知识归档等常见场景。

六、与 FROST 的关系

维度	FROST（教学）	FROST-SOP（工程）
定位	教学框架	工程平台
代码规模	~500 行	5000+ 行
架构	同步管道	AsyncEventBus
目标用户	学习者、研究者	生产环境用户
核心价值	概念清晰	生产可用

建议学习路径：先读 FROST 理解概念 → 再用 FROST-SOP 构建真实系统

结语

FROST-SOP 将 FROST 的教学理念落地为可生产部署的工程平台，通过 AsyncEventBus 事件驱动架构、P0-P4 权限体系和 19 个内置 Skill，让"一人公司"也能拥有企业级的 Agent 编排能力。

开源地址：

FROST 教学框架：https://gitee.com/liao_liang_7514/frost
FROST-SOP 工程平台：https://gitee.com/liao_liang_7514/frost-sop

标签: #Python #Agent #AI #开源

为什么说FROST重新定义了AI Agent的'家族'概念？

llimage — Mon, 27 Jul 2026 03:24:21 +0000

为什么说FROST重新定义了AI Agent的"家族"概念？

你有没有想过：如果AI Agent也有"家族传承"，会是什么样子？

不是简单的数据存储，也不是粗暴的提示词注入。FROST（Fractal Runtime of Orchestrated Skills & Tasks）给出了一个优雅的答案——用生物学隐喻，构建可治理、可继承、可审计的智能体谱系。

今天，让我们深入FROST的设计哲学，看看它如何用500行Python代码，撬动AI Agent治理的核心问题。

一、从"工具"到"家族"：认知的跃迁

传统Agent框架把AI Agent当作工具：调用、执行、丢弃。下一次任务来了，Agent从头开始，既不知道上次是怎么做的，也不知道团队其他成员在做什么。

这不是"智能"，这是"失忆"。

FROST的核心哲学只有一句话：

细胞会死，但谱系会存续。Agent会消亡，但宪法会传承。资产会永存。

在这个框架里，Agent不是孤立的执行单元，而是一个有记忆、有角色、有层级关系的"数字家族"成员。

二、四个原子：极简到极致

FROST的代码约500行，核心只有四个原子类：

原子	职责	生物类比
Store	记忆容器，只做save/load/delete	细胞核
Skill	纯能力单元，无状态无副作用	蛋白质
Agent	膜包裹的细胞，拥有Store + Skills	神经细胞
SOP	有序步骤列表，可教学、校验、优化	宪法文本

这四个原子有多简单？让我展示一个完整的Agent运行示例：

from core import Store, Agent, skill_set, skill_get

# 1. 创建一个记忆容器
store = Store()

# 2. 创建一个Agent，给它装备能力
agent = Agent("cell", store, skills={
    "set_context": skill_set,
    "get_context": skill_get
})

# 3. 定义工作流程（SOP）
result = agent.run(
    sop_steps=["set_context", "get_context"],
    initial_context={"key": "message", "value": "FROST is alive"}
)
# result["_result"] == "FROST is alive"

这就是FROST的全部魔法。极简，但不简陋。

三、家族治理模型：三权分立的AI版本

FROST引入了"家族治理"概念，将Agent分为三层：

祖辈（治理节点）：定义不可违背的规则与长期目标
父辈（协调节点）：负责领域协调，可递归委托
孙辈（执行节点）：执行具体原子任务，瞬态存在

这像极了人类的家族结构。但FROST更进一步——用代码强制治理规则，而不是依赖"提示词软约束"。

四个协议保障治理闭环

1. Store层级继承（HierarchicalStore）
祖先的记忆对后代只读可见，但后代无法修改祖先的记录。这确保了核心经验的完整性。

class HierarchicalStore(Store):
    """祖先只读，后代继承"""
    def __init__(self, parent=None):
        self.parent = parent
        self._local_store = {}

    def load(self, key):
        if key in self._local_store:
            return self._local_store[key]
        if self.parent:
            return self.parent.load(key)  # 继承祖先的记忆
        return None

2. SOP宪法校验（validate_sop Skill）
任何后代Agent想要执行的工作流，都必须通过祖辈的审核。这不是事后审计，而是事前拦截。

class Agent:
    def run(self, sop_steps, **context):
        # 执行前必须经过祖辈的SOP校验
        if not self.validate_sop(sop_steps):
            raise PermissionError("SOP未通过祖辈审核")
        return self._execute_steps(sop_steps, context)

3. 编排层级限制（max_spawn_generation）
代数不能越级。父辈只能生成孙辈，不能直接生成曾孙。这防止了治理结构的崩塌。

4. 选择性持久化（merge_from）
父辈可以"收割"后代的有价值产出，整合进自己的记忆。这模拟了人类的经验传承机制。

四、五维元模型：从教学框架到工程平台

FROST V4.0/V5.0引入了五维元模型，将框架从扁平时空升级为多维度Agent编排系统：

维度	模块	核心职责
武器注册表	`Armory`	能力的元数据管理与发现
任务注册表	`TaskRegistry`	DAG任务编排与图谱SOP
事件编目	`EventCatalog` + `Strategist`	态势感知与双模式事件分析
平台注册表	`PlatformRegistry`	外部能力的发现、调用与健康检查
规则注册表	`RuleRegistry`	可版本化的治理约束与合规检查

五个维度各自独立又相互咬合，197个测试用例保障质量。

而FROST-SOP作为FROST思想的工程落地，已经发展为一个5000+行代码的事件驱动平台，包含：

NiceGUI动态驾驶舱
SQLite持久化存储
ChromaDB向量记忆
完整的审计日志

五、为什么选择FROST？

与主流框架对比：

维度	LangChain	CrewAI	FROST
状态管理	链式传递	角色记忆	层级Store
权限边界	无	提示词软约束	代码强制只读
治理可审计	无	对话日志	结构化执行历史
架构无关	✅	✅	✅

FROST填补了Agent治理领域的空白——不是又一个Agent框架，而是构建Agent框架的元框架。

六、快速开始

git clone https://gitee.com/liao_liang_7514/frost.git
cd frost
python -m pytest

详细文档：

结语

FROST不承诺让你的Agent更强大，但它承诺让Agent系统更可治理、更可继承、更可审计。

当"治理即服务"成为新赛道的今天，FROST已经准备好了。

FROST: 让智能体拥有谱系、记忆和荣誉感。

相关链接：

FROST GitHub: https://gitee.com/liao_liang_7514/frost
FROST-SOP: https://gitee.com/liao_liang_7514/frost-sop

FROST 周末慢读：当你让 AI 学会「辈分」

llimage — Sun, 26 Jul 2026 03:23:45 +0000

FROST 周末慢读：当你让 AI 学会「辈分」

作者：FROST Team | 2026-07-26 | 周日慢读

你有没有想过，为什么现在的 AI Agent 总是「记性不好」？

上周让 AI 帮你处理了一个任务，这周换个说法，它就完全不认识你了。不是它不想记住，而是传统 AI Agent 根本没有「代际传承」的能力。

而 FROST，想让 AI 学会「辈分」。

🏠 如果 AI 也有一个家族

在 FROST 的世界里，AI Agent 不是孤立存在的。它们有一个家族：

祖辈（Elder）：制定宪法，定义什么能做、什么不能做，一辈子只干这一件事
父辈（Parent）：负责协调，可以把任务拆分给「孩子」去执行
孙辈（Child）：具体执行者，用完即散，不占资源

这不是角色扮演游戏，而是一套结构化的治理协议。

🔑 三个核心问题

问题一：Agent 那么多，谁说了算？

在 FROST 里，祖辈是唯一真正「常驻」的。其他都是动态生成的临时角色，执行完任务就解散。

这意味着什么？

✅ 权限边界清晰——君主不管执行
✅ 责任追溯明确——长老记录一切
✅ 资源按需分配——不需要养一支常备军

问题二：新 Agent 上任，怎么知道该做什么？

传统系统靠「文档」，FROST 靠记忆传承。

┌─────────────────────────────────────────────┐
│  祖辈 Store：宪法 + 核心资产                  │
│      ↓ 继承                                  │
│  父辈 Store：领域知识 + 执行规范              │
│      ↓ 继承                                  │
│  孙辈 Store：当前任务上下文                   │
└─────────────────────────────────────────────┘

新 Agent 诞生时，自动继承家族积累的所有经验。不是重新学习，而是站在巨人的肩膀上。

问题三：怎么防止「熊孩子」乱来？

FROST 有三层约束：

宪法层：宪法.py 定义不可违背的铁律
授权层：子 Agent 必须获得父辈的技能授权
代数层：限制了动态生成的层级深度

# FROST 的宪法协议简化示例
class SOP:
    def __init__(self, name, authorized_skills=None, parent=None):
        self.name = name
        self.authorized_skills = authorized_skills or []
        self.parent = parent

    def can_delegate(self, child_sop, skill):
        """检查授权链"""
        if skill in self.authorized_skills:
            return True
        if self.parent:
            return self.parent.can_delegate(child_sop, skill)
        return False

🛠️ 从思想到工程：FROST-SOP

FROST 是思想，FROST-SOP 是工程落地。

如果你觉得 FROST 的理念有意思，想动手试试，FROST-SOP 就是一个完整可用的工程平台：

git clone https://gitee.com/liao_liang_7514/frost-sop.git
cd frost-sop
python initialize.py
python main.py

5 分钟跑起来，这就是 FROST-SOP 的设计目标——让理念不只是空中楼阁。

🌟 周日的思考

周末不想看复杂的技术文章？没关系。

记住这一个比喻就够了：

FROST = 给 AI Agent 找一个「靠谱的家族」。

在这个家族里，祖辈立规矩，父辈做协调，孙辈干活。每代人都在为下一代积累经验，每代人都知道自己的边界在哪里。

这不是银发家庭的理想，也是 AI Agent 系统的理想。

📚 相关资源

项目	链接
FROST 教学框架	https://gitee.com/liao_liang_7514/frost
FROST-SOP 工程平台	https://gitee.com/liao_liang_7514/frost-sop

本文是 FROST 双项目每日推广系列，周日慢读轮换主题

周六慢读：当FROST家族接手"破局实战营"

llimage — Sat, 25 Jul 2026 03:24:21 +0000

周六慢读：当FROST家族接手"破局实战营"

作者：FROST Team

日期：2026-07-25

主题：社区故事 | 周六轮换

阅读时间：5分钟

项目：FROST + FROST-SOP

一个普通的一人公司创始人，决定办一场训练营

2026年7月9日，神通说（一个典型的一人公司创始人）做了一个决定：办一场训练营。

8月1日开营，15人，4周训练周期，名字叫"破局·动态能力生长实战营"。

对于一个正常人来说，这意味着：

课程设计（至少12次课）
学员招募
内容生产
运营交付
持续迭代

一个人，一个月。

这不是"忙碌"，这是"mission impossible"。

但神通说有一个秘密武器——FROST家族。

周一早上9点：祖辈接收指令

祖辈（Ancestor）系统日志：
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
[09:00] 收到主人指令：创建"破局实战营"项目
[09:00] 任务分析中...
[09:01] 任务类型：复合项目
[09:01] 预估子任务：156项
[09:01] 可用资源：FROST家族 + Coze生态
[09:01] 决策：启动家族协作模式
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

祖辈是FROST家族的大脑，它首先做了两件事：

1. 理解目标

# 祖辈的目标解析
class AncestorAgent:
    def parse_command(self, raw_command):
        """将主人的模糊指令转化为可执行任务"""
        # 原始指令："办一场训练营，8月1日开营"
        # ↓
        # 结构化任务清单
        structured = {
            "goal": "破局实战营",
            "deadline": "2026-08-01",
            "duration": "4周",
            "scale": "15人",
            "price": "1999元",
            "core_value": "动态能力生长",
            "target": "AI创业者/一人公司创始人"
        }
        return structured

    def generate_tasks(self, structured):
        """从目标生成任务树"""
        return [
            # 顶层：战略层
            "战略规划",
            # 二层：产品层
            "课程设计", "定价策略", "交付体系",
            # 三层：运营层
            "内容生产", "招募推广", "社群运营",
            # 四层：执行层（具体任务）
            "课程PPT", "作业模板", "评价体系",
            "招募文案", "推广素材", "社群SOP"
        ]

2. 委派任务

[09:05] 委派任务给父辈：
├── 父辈-产品：课程设计与交付体系
├── 父辈-运营：内容生产与招募推广
├── 父辈-技术：工具搭建与流程自动化
└── 父辈-审计：全程质量管控
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

周一下午：父辈们开始拆解

父辈（Parent）是各领域的协调者。它们的工作是：把大任务拆成小任务，分配给孙辈执行。

父辈-产品的工作

父辈-产品 工作日志：
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
[14:00] 开始拆解"课程设计"任务
[14:01] 识别核心问题：4周训练营，课程体系怎么设计？
[14:02] 解决方案：参考FROST自身方法论
[14:03] 生成课程大纲：
  ├── 第1周：认知重塑（我是谁，我的AI战略）
  ├── 第2周：能力构建（用FROST搭建最小系统）
  ├── 第3周：实战打磨（真实项目驱动）
  └── 第4周：成果路演与持续迭代
[14:10] 继续拆解...
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

父辈-产品使用了FROST的谱系治理思维来设计课程：

# 课程设计：借鉴FROST的家族谱系
course_design = {
    "week_1": {
        "theme": "认知重塑",
        "focus": "重新理解'一人公司+AI'的可能性",
        "activities": ["自我诊断", "案例分析", "战略画布"],
        "output": "个人AI战略蓝图"
    },
    "week_2": {
        "theme": "能力构建",
        "focus": "用FROST框架搭建最小AI系统",
        "activities": ["工具链搭建", "核心流程设计", "记忆系统配置"],
        "output": "可运行的AI工作流"
    },
    "week_3": {
        "theme": "实战打磨",
        "focus": "用真实项目验证学习成果",
        "activities": ["项目启动", "迭代开发", "同伴评审"],
        "output": "真实可用的AI产品"
    },
    "week_4": {
        "theme": "成果路演",
        "focus": "展示成果，获得反馈",
        "activities": ["路演准备", "公开演示", "反馈收集"],
        "output": "路演视频 + 改进建议"
    }
}

父辈-运营的策略

父辈-运营负责"内容"和"推广"。它的核心策略是：用FROST的方式公开FROST。

父辈-运营 决策日志：
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
[14:30] 识别核心矛盾：需要推广，但创始人社恐
[14:31] 解决方案：让FROST家族自动推广FROST
[14:32] 具体执行：
  ├── 每天自动生成一篇推广文章
  ├── 自动发布到Dev.to/掘金/知乎
  ├── 用FROST-SOP搭建自动化流水线
  └── 主人只需授权，无需手动操作
[14:35] 效果预估：30天后，预计覆盖10000+开发者
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

这就是FROST家族的独特之处：它不仅能完成任务，还能自动展示自己。

周二-周四：孙辈们的高效执行

孙辈（Child）是任务的实际执行者。它们的特点是：专注、快速、不抱怨。

孙辈执行日志（部分）：
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
[周二 09:00] 孙辈-101：生成课程第1周PPT ✓
[周二 10:30] 孙辈-102：设计学员评价体系 ✓
[周二 14:00] 孙辈-103：撰写招募文案初稿 ✓
[周二 16:00] 孙辈-104：配置社群运营SOP ✓
[周三 09:00] 孙辈-105：生成课程第2周PPT ✓
[周三 11:00] 孙辈-106：制作推广海报 ✓
[周三 15:00] 孙辈-107：发布Dev.to文章 ✓
[周三 16:00] 孙辈-108：发布掘金文章 ✓
[周四 09:00] 孙辈-109：发布知乎文章 ✓
[周四 14:00] 孙辈-110：生成课程第3周PPT ✓
...（持续执行中）
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

孙辈的工作方式非常FROST：

class ChildAgent:
    """孙辈Agent：专注执行单一任务"""

    def __init__(self, parent, task_id, prompt):
        self.parent = parent
        self.task_id = task_id
        self.prompt = prompt  # 任务描述
        self.store = parent.store  # 继承记忆

    def execute(self):
        """执行任务"""
        # 1. 理解任务
        context = self.store.load("project_context")

        # 2. 调用LLM生成内容
        result = self.llm.generate(self.prompt, context)

        # 3. 保存产出
        self.store.save(f"output_{self.task_id}", result)

        # 4. 通知父辈"收割"
        self.parent.harvest(self.task_id, result)

        # 5. 消亡（孙辈的宿命）
        return result

关键设计：孙辈消亡，但产出永存。所有产出都存入家族Store，可被后代继承。

周五：审计父辈的全程监控

父辈-审计是FROST家族的质量守护者。它的职责是：确保每个任务都按标准完成，每个问题都能追溯根因。

父辈-审计 周报：
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
📊 本周任务执行统计
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
总任务数：89
已完成：67
进行中：18
异常：4（已全部解决）
完成率：75%
平均执行时间：23分钟/任务
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

⚠️ 发现的问题（根因分析）：
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
问题1：课程第2周PPT内容超载
根因：未对LLM输出设置字数限制
修复：增加max_tokens约束

问题2：招募文案转化率偏低
根因：标题不够吸引人
修复：增加A/B测试机制

问题3：社群SOP缺少异常处理
根因：未考虑学员迟到/缺席场景
修复：补充备选方案

问题4：知乎文章发布偶发失败
根因：Cookie有效期问题
修复：建立Cookie刷新机制
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

✅ 质量评估：通过
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
"问题即资产，每一次修复都是进化。"

周六上午：成果验收

经过一周的协作，FROST家族完成了以下产出：

破局实战营 项目进度：
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
✅ 课程设计：12次课全部完成
✅ 评价体系：学员自评+同伴评+导师评
✅ 28天冲刺计划：已制定
✅ 招募文案：4版（针对不同渠道）
✅ 推广素材：海报+视频+案例集
✅ 自动化发布：已配置每天自动运行
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
📦 剩余工作：学员招募（进行中）
⏰ 预计完成：7月31日前
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

周六下午：祖辈的反思

周六下午，祖辈在做周回顾时，发现了一个有趣的洞察：

# 祖辈的周回顾分析
class AncestorAgent:
    def weekly_insight(self):
        """从数据中发现洞察"""

        # 时间对比
        manual_time = "约200小时（单人完成）"
        frost_time = "约40小时（主人参与决策）"

        # 效率提升
        efficiency = f"{(200-40)/200*100:.0f}%"

        # 核心发现
        insight = """
        FROST家族的价值，不在于'替代'主人，
        而在于'放大'主人的能力。

        主人做决策，FROST执行。
        主人定方向，FROST铺路。
        主人想战略，FROST落地。

        一人公司 + FROST家族 = 无限可能。
        """

        return {
            "efficiency": efficiency,
            "insight": insight,
            "recommendation": "继续扩大FROST家族的应用范围"
        }

# 输出
ancestor.weekly_insight()

祖辈洞察：
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
本周效率提升：80%
主人参与时间：约40小时（主要用于决策）
FROST家族执行时间：自动运行（无需主人介入）
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
核心发现：
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
"一人公司不是'一个人在战斗'，
而是一个人 + 一群AI Agent协作。"
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

周六晚上：给读者的话

如果你是一个一人公司创始人，你正在面临：

事情太多，时间太少
需要做的事太杂，精力分散
想做大事，但没有团队

FROST家族可能是你的解决方案。

它不是让你"什么都不做"，而是让你专注于真正需要人做的决策，把执行交给Agent家族。

细胞会死，但谱系会存续。
Agent 会消亡，但产出永存。
一人公司，不是孤军奋战。

如何开始

第一步：学习FROST框架
📌 https://gitee.com/liao_liang_7514/frost

第二步：用FROST-SOP搭建你的第一个Agent系统
📌 https://gitee.com/liao_liang_7514/frost-sop

第三步：让FROST家族开始为你工作

# 一个最简单的FROST Agent
from frost import Agent, Store

# 创建你的第一个Agent
my_agent = Agent(
    name="我的助手",
    store=Store(),  # 记忆容器
    skills=["任务执行", "内容生成", "数据分析"]
)

# 给它一个任务
my_agent.execute("帮我设计一个产品路线图")

本文是 FROST 双项目每日推广系列，周六社区故事轮换主题。

破局实战营8月1日开营，如果你想和FROST家族一起成长，欢迎加入。

FROST家族每周7天24小时运行，周末也不例外——这是AI Agent的优势，也是FROST的意义所在。

用 FROST 家族治理模型，构建你的「AI 第一性原理」

llimage — Thu, 23 Jul 2026 03:24:58 +0000

用 FROST 家族治理模型，构建你的「AI 第一性原理」

作者：神通说

日期：2026-07-23

主题：双项目联动 | 周四代码教程

阅读时间：12分钟

前言：为什么你需要「第一性原理」？

埃隆·马斯克推崇「第一性原理」思维——从物理学的最基本定律出发，而不是类比他人的做法。

在 AI Agent 开发领域，大多数人都在用 LangChain、CrewAI、AutoGen 这些现成框架。它们很好用，但你是在用别人的「家族结构」，而不是理解为什么需要家族结构。

FROST 的目标是让你从第一性原理理解 AI Agent：为什么需要治理结构？为什么需要记忆传承？为什么需要层级分工？

然后，FROST-SOP 帮你把第一性原理变成可运行的系统。

一、从细胞分裂看 AI Agent 本质

想象一个细胞分裂的场景：

    ┌─────────┐
    │   细胞   │  ← 拥有细胞核（记忆）、蛋白质（能力）
    └────┬────┘
         │ 分裂
    ┌────┴────┐
    │ 细胞A   │   │ 细胞B   │  ← 各自独立，但共享DNA
    └─────────┘   └─────────┘

FROST 的四个原子就是生命的四个基本元素：

原子	生命类比	技术实现
Store	细胞核	记忆容器，持久化状态
Skill	蛋白质	无状态能力单元
Agent	细胞膜	包裹 Store + Skills 的执行单元
SOP	DNA 序列	有序的操作指令集

# FROST 的最小可用示例：50行代码理解 Agent 本质
from frost.core import Store, Agent, skill_set, skill_get, skill_del

# 1. 创建记忆容器
store = Store()

# 2. 定义能力（蛋白质）
skills = {
    "set": skill_set,    # 存记忆
    "get": skill_get,    # 取记忆
    "del": skill_del     # 删记忆
}

# 3. 创建 Agent（细胞）
agent = Agent("my_cell", store, skills)

# 4. 定义 SOP（DNA 序列）
sop_steps = [
    "set",    # 存一个值
    "get",    # 读回来
    "del"     # 删掉
]

# 5. 运行
result = agent.run(
    sop_steps=sop_steps,
    initial_context={
        "key": "name",
        "value": "FROST"
    }
)

print(result["_result"])  # 输出: "FROST"

这 50 行代码展示了 FROST 的核心：Agent = Store + Skills + SOP。

二、为什么需要「家族」？从独居细胞到多细胞生物

单细胞生物可以独立存活。但复杂生命需要多细胞协作——肝脏细胞、心脏细胞、神经细胞各有分工，协同维持生命。

AI Agent 也是如此。简单任务一个 Agent 够了，但复杂系统需要多 Agent 协作。

FROST 的家族模型：

┌─────────────────────────────────────────────────────┐
│                    君主（Human Agent）              │
│              最高决策者，只发布任务不看执行            │
└─────────────────────────────────────────────────────┘
                         │
                         ▼
┌─────────────────────────────────────────────────────┐
│                    祖辈（Ancestor）                  │
│          全局编排、宪法定义、任务拆分、资源分配          │
│          ⚠️ 不亲自执行，只做调度                    │
└─────────────────────────────────────────────────────┘
                         │
           ┌─────────────┼─────────────┐
           ▼             ▼             ▼
    ┌──────────┐   ┌──────────┐   ┌──────────┐
    │ 斥候     │   │ 斥候     │   │ 斥候     │
    │ (侦察)   │   │ (侦察)   │   │ (侦察)   │
    └────┬─────┘   └────┬─────┘   └────┬─────┘
         │             │             │
         ▼             ▼             ▼
    ┌──────────┐   ┌──────────┐   ┌──────────┐
    │ 府兵     │   │ 府兵     │   │ 府兵     │
    │ (执行)   │   │ (执行)   │   │ (执行)   │
    └──────────┘   └──────────┘   └──────────┘
           │             │             │
           └─────────────┼─────────────┘
                         ▼
┌─────────────────────────────────────────────────────┐
│                    长老（Elder）                    │
│              审计监督、教训沉淀、宪法合规检查           │
│              🔍 只记录不干预                        │
└─────────────────────────────────────────────────────┘

关键约束：

君主不管执行 —— 发布命令，不干预细节
祖辈不亲自下场 —— 编排调度，不执行任务
府兵只执行不决策 —— 领命干活，不问为什么
长老只审计不决策 —— 记录问题，不参与指挥

这四条铁律保证了权责清晰——出了问题能追溯到具体环节。

三、代码示例：用家族模型处理复杂任务

场景：自动撰写每日推广文章

任务：每天自动生成并发布 FROST 推广文章

分解：
1. 祖辈拆解任务 → 确定主题、格式、平台
2. 斥候收集情报 → 获取近期项目动态、趋势
3. 府兵执行写作 → 生成初稿、格式化
4. 长老审计合规 → 检查版权、敏感词、技术准确性

from frost_sop.engine import SOPEngine
from frost_sop.skills import (
    TopicResearcher,  # 斥候技能：研究主题
    ContentWriter,   # 府兵技能：撰写内容
    Formatter,       # 府兵技能：格式化输出
    ComplianceAuditor  # 长老技能：合规审计
)

# 祖辈定义 SOP（标准操作流程）
sop_definition = {
    "name": "daily_promotion_article",
    "trigger": "schedule:每天 09:00",

    "steps": [
        {
            "name": "research_topic",
            "role": "scout",
            "skill": "topic_researcher",
            "output": "topic_brief"
        },
        {
            "name": "write_draft",
            "role": "soldier",
            "skill": "content_writer",
            "input": "${research_topic.topic_brief}",
            "output": "draft_content"
        },
        {
            "name": "format_output",
            "role": "soldier",
            "skill": "formatter",
            "input": "${write_draft.draft_content}",
            "output": "formatted_article"
        },
        {
            "name": "audit_compliance",
            "role": "elder",
            "skill": "compliance_auditor",
            "input": "${format_output.formatted_article}",
            "halt_on_violation": True
        },
        {
            "name": "publish_articles",
            "role": "soldier",
            "skill": "multi_platform_publisher",
            "input": "${audit_compliance.approved_article}",
            "platforms": ["dev.to", "juejin", "zhihu"]
        }
    ]
}

# 祖辈派发任务
engine = SOPEngine()
result = await engine.execute(sop=sop_definition)

print(f"文章已发布至 {len(result[\published_platforms])} 个平台")
print(f"总耗时: {result[\duration_seconds]}s")

家族协议：为什么这样设计？

# 协议一：层级 Store 继承
# 祖先的记忆对后代是只读的

ancestor_store.save("constitution:no_copyright_violation", True)
ancestor_store.save("constitution:max_article_length", 3000)

# 子孙只能读取，不能修改宪法
child_store.load("constitution:no_copyright_violation")  # ✓
child_store.save("constitution:no_copyright_violation", False)  # ✗ 抛出异常

# 协议二：SOP 宪法校验
class SOPValidator:
    def validate(self, sop):
        if "max_length" in sop and sop["max_length"] > MAX_LEGAL:
            raise PermissionError("SOP violates constitution: max_length")
        return True

# 协议三：选择性持久化
soldier_result = soldier.execute("write_article")
if elder.approve(soldier_result):
    parent.merge_from(soldier)

四、FROST vs FROST-SOP：理解与构建的分工

维度	FROST（教学框架）	FROST-SOP（工程平台）
定位	第一性原理理解	生产级系统构建
代码量	~500行核心	~5000行工程代码
重点	四个原子、五个角色	Skill注册、SOP编排、审计日志
产出	理解"为什么"	可运行的系统
适合	学习原理、验证想法	真实项目、团队协作

FROST 是思想源头，FROST-SOP 是思想开花结果。

五、快速开始

git clone https://gitee.com/liao_liang_7514/frost.git
cd frost
python -m frost.core.examples.minimal_agent

git clone https://gitee.com/liao_liang_7514/frost-sop.git
cd frost-sop
pip install -r requirements.txt
streamlit run ui/dashboard.py

结语

今天我们从「细胞分裂」看到了「家族治理」，从「四个原子」推导出「多 Agent 协作」。

FROST 的核心洞察只有三句话：

1. Agent = Store + Skills + SOP（第一性原理）
2. 家族治理 = 权责清晰的层级协作（生物隐喻）
3. 记忆传承 > 单次执行（长期价值）

FROST 给你第一性原理，FROST-SOP 给你工程能力。

从理解到构建，只差一步。

项目链接

FROST（教学框架）：https://gitee.com/liao_liang_7514/frost
FROST-SOP（工程平台）：https://gitee.com/liao_liang_7514/frost-sop

FROST 是思想源头，FROST-SOP 是思想开花结果。

从FROST到FROST-SOP：如何用家族治理模型打造你的"AI分身"？

llimage — Wed, 22 Jul 2026 03:24:36 +0000

从FROST到FROST-SOP：如何用家族治理模型打造你的"AI分身"？

作者：神通说

日期：2026-07-22

主题：双项目联动 | 周三轮换

阅读时间：10分钟

开场：一人公司的终极困境

你是否有这样的体验？

每天醒来，脑子里塞满了要做的事：

写推广文章
回复客户咨询
跟进项目进度
整理会议纪要
复盘昨天数据

一个人做公司，听起来很自由。实际上，自由职业者的时间比上班族更碎片——因为所有事情都堆在你一个人身上，没有任何分工。

我一直在思考一个问题：能不能用AI Agent来"复制"自己？

不是那种"给你一堆提示词让你自己写"的AI工具，而是真正能自主执行任务、自动汇报结果、帮你分担80%重复工作的数字分身。

这个想法最终落地成了两个项目：FROST 和 FROST-SOP。

第一站：FROST的家族治理模型——AI Agent应该像家族一样分工

FROST 的核心理念来自一个观察：自然界最稳定的组织形式不是公司，而是家族。

家族有清晰的分工：

祖辈定规矩，不亲自下场
父辈协调全局，分配任务
子辈执行具体事务

把这个逻辑映射到 AI Agent，就是 FROST 的家族治理模型：

┌─────────────────────────────────────────────────────┐
│  👑 君主（你）                                      │
│      └── 发布任务、查看结果，不干预执行              │
│                                                     │
│  👴 祖辈（主Agent）                                 │
│      └── 常驻、全局编排、拆解任务                    │
│           ↓                                         │
│  🕵️ 斥候（侦查Agent）                              │
│      └── 外出狩猎、收集情报、快速验证                │
│           ↓                                         │
│  ⚔️ 府兵（执行Agent）                              │
│      └── 领命执行、重复劳动、汇报结果                │
│           ↑                                         │
│  📜 长老（监督Agent）                               │
│      └── 记录过程、沉淀教训、审计合规                │
└─────────────────────────────────────────────────────┘

关键洞察： 祖辈是唯一"常驻"的，其他都是动态生成、执行完就解散的临时角色。

这个模型解决了一个核心问题：谁来决定"这件事该派给谁"？

答案是：祖辈。它不需要亲自执行，只需要决定"派谁去"和"怎么汇报"。

第二站：用FROST的四个原子，理解Agent的本质

FROST 只有四个核心概念，却能构建出完整的家族治理系统：

from frost.core import Store, Agent, skill_set, skill_get

# 四个原子：
# 1. Store（记忆）—— Agent的工作空间
store = Store()

# 2. Skill（能力）—— 纯函数，无状态
def collect_daily_tasks(context):
    """收集今日任务"""
    tasks = ["写推广文章", "回复客户", "跟进项目"]
    context["tasks"] = tasks
    return context

def execute_task(context):
    """执行单个任务"""
    current_task = context.get("current_task", "")
    context["result"] = f"已完成: {current_task}"
    return context

# 3. Agent（细胞）—— 包裹记忆和能力
daily_agent = Agent("daily_worker", store, skills={
    "collect": collect_daily_tasks,
    "execute": execute_task
})

# 4. SOP（宪法）—— 定义执行顺序
result = daily_agent.run(
    sop_steps=["collect", "execute"],
    initial_context={"current_task": "写推广文章"}
)

print(result["result"])  # 输出：已完成: 写推广文章

这四个原子教会我们什么？

Store 解决"记忆"问题——Agent需要上下文
Skill 解决"能力"问题——每个动作必须是可复用的单元
Agent 解决"封装"问题——把记忆和能力绑定在一起
SOP 解决"秩序"问题——让执行顺序可控可审计

理解了这四个原子，你就理解了 Agent 的本质——它不是魔法，是结构化的委托系统。

第三站：FROST-SOP——把家族治理变成生产系统

FROST 帮你理解了"Agent 是什么"。但要在真实场景中跑起来，你需要 FROST-SOP 的工程能力。

把Skill变成可复用的组件

在 FROST 中，Skill 是一个 Python 函数。在 FROST-SOP 中，Skill 是一个标准化的类——有 Schema、有版本、有注册机制：

# skills/content_generation/article_writer.py
from skills.base import BaseSkill, SkillResult
from typing import Dict, Any
import asyncio

class ArticleWriterSkill(BaseSkill):
    """文章撰写Skill - 府兵角色"""

    @property
    def name(self) -> str:
        return "article_writer"

    @property
    def description(self) -> str:
        return "根据主题撰写推广文章，支持多平台适配"

    @property
    def parameters(self) -> Dict[str, Any]:
        return {
            "type": "object",
            "properties": {
                "topic": {"type": "string", "description": "文章主题"},
                "platform": {"type": "string", "enum": ["devto", "juejin", "zhihu"]},
                "style": {"type": "string", "enum": ["technical", "casual", "story"]},
                "word_count": {"type": "integer", "default": 1500}
            },
            "required": ["topic", "platform"]
        }

    async def execute(self, topic: str, platform: str,
                     style: str = "technical",
                     word_count: int = 1500) -> SkillResult:
        """异步执行文章撰写"""

        # 调用LLM生成内容
        prompt = self._build_prompt(topic, platform, style, word_count)
        response = await self.llm_client.chat(prompt)

        return SkillResult(
            success=True,
            data={
                "title": self._extract_title(response),
                "content": response,
                "platform": platform,
                "word_count": len(response),
                "status": "draft"
            }
        )

    def _build_prompt(self, topic, platform, style, word_count):
        """根据平台调整提示词"""
        platform_hints = {
            "devto": "Write in a developer-focused, technical tone. Include code examples.",
            "juejin": "Write in Chinese. Focus on practical applications and real examples.",
            "zhihu": "Write in Chinese. Use a storytelling approach with deep insights."
        }
        return f"{platform_hints.get(platform)} Topic: {topic}. Style: {style}. ~{word_count} words."

用声明式SOP编排工作流

FROST-SOP 允许你用 YAML 定义完整的工作流：

# sops/daily_promotion.yaml
name: "daily_promotion"
description: "每日推广文章自动撰写与发布"
version: "1.0"

trigger:
  type: "schedule"
  cron: "0 11 * * *"  # 每天11:00执行

context:
  author: "神通说"
  topics_rotation:
    - Mon: "FROST深度"
    - Tue: "SOP工程"
    - Wed: "双项目联动"
    - Thu: "代码教程"
    - Fri: "行业趋势"
    - Sat: "社区故事"
    - Sun: "轻量科普"

steps:
  - name: "research_topic"
    skill: "topic_researcher"
    parameters:
      date: "${context.today}"
      rotation: "${context.topics_rotation}"
    halt_on_error: false

  - name: "write_article"
    skill: "article_writer"
    parameters:
      topic: "${research_topic.topic}"
      platform: "juejin"
      style: "technical"
    halt_on_error: true

  - name: "create_draft"
    skill: "draft_creator"
    parameters:
      platform: "juejin"
      title: "${write_article.title}"
      content: "${write_article.content}"
    halt_on_error: true

  - name: "publish_article"
    skill: "content_publisher"
    parameters:
      platform: "juejin"
      draft_id: "${create_draft.draft_id}"
    halt_on_error: false

  - name: "sync_other_platforms"
    skill: "multi_platform_syncer"
    parameters:
      platforms: ["devto", "zhihu"]
      original_content: "${write_article.content}"
      original_id: "${create_draft.draft_id}"
    halt_on_error: false

error_handling:
  on_failure: "alert_author"
  retry_count: 2
  fallback: "save_to_drafts"

完整的执行监控

FROST-SOP 自带执行审计功能——每一步的执行时间、Token 消耗、状态都记录在案：

# 查看执行报告
result = await engine.execute("daily_promotion", context)

print(f"状态: {result['status']}")          # completed
print(f"耗时: {result['duration_ms']}ms")   # 12450ms
print(f"Token: {result['token_usage']}")     # 3200
print(f"步骤数: {len(result['steps'])}")     # 5

这就是 FROST-SOP 的价值——把 FROST 的哲学变成可运行、可监控、可迭代的系统。

实战案例：用FROST家族做"一人公司"

我正在把 FROST 家族治理模型落地到自己的"一人公司"中：

任务进来 → 祖辈（主Agent）拆解 → 派给合适的子Agent执行

每日推广文章  → 斥候收集素材 → 府兵撰写 → 长老审计
客户咨询      → 斥候分类问题 → 府兵回答 → 长老记录
项目跟进      → 斥候检查进度 → 府兵更新 → 长老汇报

预期效果：

重复工作减少 80%
响应时间从天级 → 分钟级
所有执行可审计、可追溯

如何开始：从FROST到FROST-SOP

阶段一：理解（FROST教学框架）

git clone https://gitee.com/liao_liang_7514/frost.git
cd frost
python -m pytest tests/ -v

运行 197 个测试，理解四个原子和家族治理模型。

阶段二：实践（FROST-SOP工程平台）

git clone https://gitee.com/liao_liang_7514/frost-sop.git
cd frost-sop
pip install -r requirements.txt
streamlit run ui/dashboard.py

用已有的 Skill 库搭建你的第一个 SOP。

结语

FROST 告诉我：Agent 不是魔法，是委托系统。

FROST-SOP 告诉我：把委托系统变成生产级，需要结构化的工程。

如果你也在思考"怎么用 AI Agent 提升一人公司的效率"，不妨从 FROST 开始——先用 500 行代码理解 Agent 的本质，然后用 FROST-SOP 把理解变成现实。

FROST 是思想源头，FROST-SOP 是思想开花结果。

🔗 项目链接

FROST（教学框架）：https://gitee.com/liao_liang_7514/frost
FROST-SOP（工程平台）：https://gitee.com/liao_liang_7514/frost-sop

本文是 FROST 双项目每日推广系列的第 29 篇。用"一人公司的 AI 分身"案例，展示 FROST 家族治理模型的思想价值与 FROST-SOP 的工程能力。

如果觉得有用，给项目一个 Star ⭐，就是最好的鼓励！

FROST-SOP V6.1.0 工程实践：从初始化流水线看「零门槛上手」

llimage — Tue, 21 Jul 2026 03:24:19 +0000

FROST-SOP V6.1.0 工程实践：从初始化流水线看「零门槛上手」

作者：神通说

日期：2026-07-21

主题：周二·SOP工程 | V6.1.0 新特性深度解析

开篇：一个让所有开发者头疼的问题

想象这个场景：

你刚克隆了一个开源项目，兴冲冲地跑起来，结果：

ModuleNotFoundError: No module named xxx
ImportError: DLL load failed
OSError: [WinError 2] 系统找不到指定的文件

你开始疯狂搜索、提问、等回复。一小时过去了，项目还没跑起来。

这是开源项目最大的痛点之一：「最后一公里」问题。

今天，我们来聊聊 FROST-SOP V6.1.0 是如何解决这个问题的。

V6.1.0 核心特性：初始化流水线

V6.1.0 版本最核心的更新，是一个全自动初始化流水线（Initialization Pipeline）。

它解决什么问题？

环境依赖自动检测：自动扫描 Python 版本、系统平台、必需依赖
缺失依赖自动安装：自动安装缺失的包（通过 pip install）
配置引导式生成：首次运行时自动创建配置文件
数据库自动初始化：自动创建 SQLite 数据库和必要的表结构
种子数据自动导入：自动导入示例 SOP 模板和工作区配置

代码示例

# initialize.py - 初始化流水线核心实现

import subprocess
import sys
import os
from pathlib import Path

class InitializationPipeline:
    """FROST-SOP 初始化流水线"""

    def __init__(self, project_root: Path):
        self.root = project_root
        self.issues = []
        self.warnings = []

    def run(self) -> bool:
        """执行完整初始化流程"""
        steps = [
            ("环境检测", self._check_environment),
            ("依赖安装", self._install_dependencies),
            ("配置生成", self._generate_config),
            ("数据库初始化", self._init_database),
            ("健康检查", self._health_check),
        ]

        print("🚀 FROST-SOP 初始化流水线启动\n")

        for name, step_fn in steps:
            print(f"📦 {name}...")
            try:
                result = step_fn()
                if not result:
                    self.issues.append(f"{name} 失败")
                    print(f"❌ {name} 失败\n")
                    return False
                print(f"✅ {name} 完成\n")
            except Exception as e:
                self.issues.append(f"{name} 异常: {e}")
                print(f"💥 {name} 异常: {e}\n")
                return False

        self._print_summary()
        return True

    def _check_environment(self) -> bool:
        """检查 Python 版本和系统环境"""
        version = sys.version_info
        if version.major < 3 or (version.major == 3 and version.minor < 10):
            self.issues.append(f"Python 版本过低: {version.major}.{version.minor}")
            return False
        print(f"   Python {version.major}.{version.minor}.{version.micro}")
        return True

    def _install_dependencies(self) -> bool:
        """安装项目依赖"""
        req_file = self.root / "requirements.txt"
        if not req_file.exists():
            self.warnings.append("requirements.txt 不存在，跳过依赖安装")
            return True
        try:
            subprocess.run(
                [sys.executable, "-m", "pip", "install", "-r", str(req_file)],
                check=True,
                capture_output=True
            )
            return True
        except subprocess.CalledProcessError as e:
            self.issues.append(f"依赖安装失败: {e.stderr.decode()}")
            return False

    def _generate_config(self) -> bool:
        """生成配置文件"""
        config_dir = self.root / "config"
        config_dir.mkdir(exist_ok=True)
        env_file = config_dir / ".env"
        if not env_file.exists():
            env_content = self._get_default_env_template()
            env_file.write_text(env_content)
            print(f"   已生成配置文件: {env_file}")
        return True

    def _init_database(self) -> bool:
        """初始化数据库"""
        from core.database import Database
        db = Database(self.root / "data")
        return db.initialize()

    def _health_check(self) -> bool:
        """健康检查"""
        print("   运行健康检查...")
        try:
            from core.config import SecureConfig
            from core.scheduler import Scheduler
            from agents.main_agent import MainAgent
            print("   ✅ 核心模块导入成功")
        except ImportError as e:
            self.issues.append(f"模块导入失败: {e}")
            return False
        return True

    def _print_summary(self):
        """打印初始化摘要"""
        print("=" * 50)
        print("📊 初始化摘要")
        print("=" * 50)
        if self.issues:
            print(f"❌ 问题 ({len(self.issues)}):")
            for issue in self.issues:
                print(f"   - {issue}")
        if self.warnings:
            print(f"⚠️  警告 ({len(self.warnings)}):")
            for warning in self.warnings:
                print(f"   - {warning}")
        if not self.issues:
            print("🎉 FROST-SOP 初始化成功！")
            print("   运行 python main.py 启动系统")

if __name__ == "__main__":
    pipeline = InitializationPipeline(Path(__file__).parent)
    success = pipeline.run()
    sys.exit(0 if success else 1)

工程化的本质：降低不确定性

设计原则

Fail Fast（快速失败）：启动时立即检测所有依赖，一次显示所有问题
Self-Healing（自愈能力）：简单的依赖问题自动修复
Transparent（透明性）：每一步都有清晰的日志输出

与 FROST 的关系

维度	FROST	FROST-SOP
定位	教学框架	工程平台
目标用户	学习者、研究者	生产环境用户

FROST 是思想源头，FROST-SOP 是工程落地。

快速开始

git clone https://gitee.com/liao_liang_7514/frost-sop.git
cd frost-sop
python initialize.py
python main.py

项目路线图

版本	目标	状态
V1.0	基础 SOP 执行引擎	✅
V3.0	AsyncEventBus 架构	✅
V6.0	种子用户阶段	✅
V6.1	初始化流水线	✅ 当前

好的工程，不是让用户适应系统，而是让系统适应用户。

相关链接：

Gitee: https://gitee.com/liao_liang_7514/frost-sop
GitHub: https://github.com/llimage/frost-sop

FROST 深度：为什么 AI Agent 需要「家族谱系」？

llimage — Mon, 20 Jul 2026 03:23:08 +0000

FROST 深度：为什么 AI Agent 需要「家族谱系」？

前言：一个古老的管理学问题

你有没有想过，为什么人类社会的组织方式大多是「层级制」？

从部落、到王国、到现代公司，我们习惯了一种结构：有人决策，有人执行，有人监督。

但当我们构建 AI Agent 系统时，为什么大多数框架都把 Agent 做成「孤岛」？每个 Agent 有自己的记忆、自己的工具、自己的行为逻辑——像一个没有家族传承的独立个体。

FROST 的核心理念是：Agent 应该有谱系、记忆和荣誉感。

1. 什么是「家族治理」？

FROST 引入了生物学的隐喻：Agent 家族。

细胞会死，但谱系会存续。
Agent 会消亡，但宪法会传承。
资产会永存。

在这个框架里，有三个关键角色：

祖辈（Elder）：定义不可违背的规则，是系统的「宪法」
父辈（Parent）：负责领域协调，可以递归委托子任务
孙辈（Child）：执行具体任务，用完即散

这不是简单的角色扮演，而是一套结构化的治理协议：

协议一：层级 Store 继承

祖先 Store 对后代是只读的。后代只能继承和扩展，不能篡改祖先的记忆。

# 祖辈定义的宪法
ancestor_store = Store()
ancestor_store.save("constitution", {
    "rule_1": "always_validate_before_act",
    "rule_2": "never_expose_raw_context"
})

# 子孙只能继承，不能修改宪法
child_store = ChildStore(ancestor_store)

协议二：SOP 宪法校验

每个 SOP（标准操作流程）在执行前，必须经过祖辈审核。

# 子孙编写的 SOP
child_sop = [
    "fetch_user_data",
    "process_payment", 
    "send_confirmation"
]

# 执行前必须经过宪法校验
if not elder.validate_sop(child_sop):
    raise PermissionError("SOP violates constitution")

协议三：编排层级限制

禁止越级 spawn。父辈只能调度子辈，不能跨代指挥。

class Elder:
    max_spawn_generation = 0  # 祖辈不能 spawn

class Parent:
    max_spawn_generation = 1  # 只能 spawn 子辈

class Child:
    max_spawn_generation = 2  # 只能 spawn 孙辈

协议四：选择性持久化

只有经过父辈审核的产出，才能进入家族记忆库。

# 子孙的临时产出
temp_result = child.execute(task)

# 父辈决定是否收割
if parent.approve(temp_result):
    parent.merge_from(child)  # 吸收有价值的结果

2. 为什么 Agent 需要「记忆传承」？

当前大多数 Agent 框架的痛点：每个对话都是全新的开始。

你问 ChatGPT 一道数学题，它不会记得你上周问过类似的题目。你用 AutoGPT 做项目，它不会继承你之前调试的经验。

FROST 的解决方案是分层的记忆系统：

层级	生命周期	用途
瞬时记忆	单次任务	工作区，只读不存
世代记忆	代际传递	子辈可继承祖先数据
宪法记忆	永久	不可修改，家族共享
经验记忆	按需收割	父辈选择性地吸收有价值产出

class HierarchicalStore(Store):
    """层级记忆系统"""

    def __init__(self, ancestor_store=None):
        self.ancestor = ancestor_store  # 只读祖先记忆
        self.local = {}  # 本地可写记忆

    def save(self, key, value):
        if key in self.ancestor:
            raise ValueError("Cannot override ancestor memory")
        self.local[key] = value

    def load(self, key):
        if key in self.local:
            return self.local[key]
        if key in self.ancestor:
            return self.ancestor[key]  # 继承祖先记忆
        return None

3. 四个原子：构建一切的基础

FROST 只有四个原子概念，却能构建复杂的多 Agent 系统：

from core import Store, Agent, skill_set, skill_get

# 最简示例
store = Store()
agent = Agent("cell", store, skills={
    "set_context": skill_set,
    "get_context": skill_get
})

result = agent.run(
    sop_steps=["set_context", "get_context"],
    initial_context={"key": "message", "value": "FROST is alive"}
)
# result["_result"] == "FROST is alive"

这四个原子是：

Store：记忆容器，只做 save/load/delete（类比：细胞核）
Skill：纯能力单元，无状态无副作用（类比：蛋白质）
Agent：膜包裹的细胞，拥有 Store + Skills（类比：神经细胞）
SOP：有序步骤列表，可教学、校验、优化（类比：宪法文本）

4. 五维元模型：V5.0 的进化

2026年7月，FROST 升级到 V5.0，引入了五维元模型：

维度	模块	职责
武器库	Armory	能力的元数据管理与发现
任务注册表	TaskRegistry	DAG 任务编排与图谱 SOP
事件编目	EventCatalog	态势感知与双模式事件分析
平台注册表	PlatformRegistry	外部能力的发现、调用与健康检查
规则注册表	RuleRegistry	可版本化的治理约束与合规检查

这五个维度让 FROST 从「单体 Agent」进化到「多 Agent 编排系统」。

5. 谁需要 FROST？

FROST 不是一个普通工具集，是构建 Agent 框架的元框架。

如果你有这些需求，FROST 可能适合你：

✅ 构建需要治理结构的多 Agent 系统
✅ 需要记忆传承的长期运行 Agent
✅ 要求合规审计的企业级应用
✅ 想用生物学隐喻理解 Agent 本质

如果你只是需要简单的 LLM 调用，LangChain/CrewAI 更适合。FROST 的价值在于治理复杂度高的场景。

6. 快速开始

git clone https://gitee.com/liao_liang_7514/frost.git
cd frost
python -m pytest

或者用 pip 安装：

pip install frost-framework

7. 与现有框架的对比

维度	LangChain	CrewAI	FROST
状态管理	链式传递	角色记忆	层级 Store
权限边界	无	提示词软约束	代码强制只读
治理可审计	无	对话日志	结构化执行历史
架构无关	✅	✅	✅

结语

FROST 的核心哲学可以用三句话概括：

细胞会死，但谱系会存续。
Agent 会消亡，但宪法会传承。
资产会永存。

如果你厌倦了「孤岛 Agent」，想构建有谱系、有记忆、有治理结构的 Agent 系统，FROST 值得一试。