本文为面向工程实践的深度技术文章，详细拆解 Agent 中 Skill 的设计逻辑、加载机制、能力边界，明确 Skill 与 Tool 的核心区别，重点讲解如何通过 Skill 节省 Token 消耗，并附带 Python + Agent 框架的真实可运行代码示例，适用于多智能体系统、AI Coding、类似 Cursor / Devin 产品的开发人员参考。

| 如果你正在做多智能体系统、AI Coding、或者类似 Cursor / Devin 的产品，这一篇是关键基础设施。 |

一、什么是 Skill？

👉 一句话定义

Skill = 被结构化封装、可复用、可组合的“高阶能力单元”

它并非简单的函数（Tool），而是具备以下核心特性的完整能力模块：

• 具备上下文理解能力，能适配不同场景的输入需求
• 包含完整的执行流程，支持多步联动操作
• 自带记忆/策略，可根据历史结果调整执行逻辑
• 拥有规范的输入输出结构，便于与其他模块对接

🔥 Skill vs Tool（核心区别）

维度	Tool（工具）	Skill（技能）
粒度	原子操作（单一功能）	复杂能力（多功能组合）
是否多步	❌ 单步执行，仅完成一个具体操作	✅ 多步流程，可串联多个操作完成复杂任务
是否带上下文	❌ 基本无上下文，仅接收固定格式输入	✅ 具备上下文感知，可结合历史信息执行
是否可组合	❌ 独立存在，无法直接与其他 Tool 联动	✅ 支持多 Skill 组合，形成更复杂的能力体系
是否有策略	❌ 无策略，仅按固定逻辑执行	✅ 自带执行策略，可根据任务调整流程
Token 消耗	❌ 高（频繁调用，每次需传递完整参数和描述）	✅ 低（一次性封装，减少重复调用和参数传递）

👉 一个直观理解

Tool（像系统调用，仅实现单一功能）

python def search_google(query: str) -> str: “”“工具：仅实现谷歌搜索功能，输入查询词，返回搜索结果”“” # 模拟谷歌搜索逻辑 import requests response = requests.get(f"https://www.google.com/search?q={query}") return response.text

Skill（像一个“能力模块”，串联多个工具完成复杂任务）

python class ResearchSkill: “”“技能：完成主题研究，串联搜索、总结、提炼洞察三个步骤”“” def run(self, topic: str) -> dict: # 步骤1：调用搜索工具获取原始数据 data = search_google(topic) # 步骤2：调用总结工具清洗、提炼核心信息 cleaned_data = self.summarize_data(data) # 步骤3：调用洞察提取工具获取关键结论 insights = self.extract_insights(cleaned_data) # 返回结构化结果 return { “topic”: topic, “cleaned_data”: cleaned_data, “insights”: insights, “status”: “success” } def summarize_data(self, data: str) -> str: “”“辅助方法：总结搜索到的原始数据”“” # 模拟总结逻辑（实际可调用LLM实现） return data[:500] + “…”# 截取核心内容 def extract_insights(self, cleaned_data: str) -> list: “”“辅助方法：从总结数据中提取洞察”“” # 模拟洞察提取逻辑（实际可调用LLM实现） return [insight.strip() for insight in cleaned_data.split(“.”) if insight.strip()]

👉 核心逻辑：Skill = Tool（基础操作） + Flow（执行流程） + Memory（过程记忆） + Reasoning（决策逻辑）

二、Skill 如何设计？

1️⃣ Skill 标准结构（推荐范式）

为保证 Skill 的可复用性、可组合性和可维护性，推荐采用以下标准类结构，所有自定义 Skill 均继承此基础结构：

python class Skill: “”“Skill 基础类，定义所有 Skill 必须实现的核心方法和属性”“” # Skill 名称（唯一标识，用于注册和调度） name: str # Skill 描述（详细说明功能、适用场景、输入输出格式） description: str def can_handle(self, task: str) -> bool: “”“判断当前 Skill 是否能处理目标任务 Args: task: 待处理的任务描述（字符串） Returns: bool: 能处理返回True，否则返回False “”” raise NotImplementedError(“子类必须实现 can_handle 方法”) def run(self, input: dict, context: dict = None) -> dict: “”“执行 Skill 核心逻辑，完成任务处理 Args: input: 输入参数（结构化字典，明确key和数据类型） context: 上下文信息（可选，包含历史执行记录、环境参数等） Returns: dict: 结构化输出结果，包含状态、数据等关键信息 “”” raise NotImplementedError(“子类必须实现 run 方法”)

2️⃣ 一个真实 Skill 示例（代码生成 Skill）

基于上述标准结构，实现一个生产级的代码生成 Skill，可直接集成到 Agent 框架中使用：

python class CodeGenSkill(Skill): “”“Skill：生成生产级 Python 代码，支持根据需求描述生成可运行代码”“” name = “code_generation” description = “用于根据用户提供的需求描述，生成干净、规范、可运行的生产级 Python 代码，支持基础功能开发、工具类编写等场景，输入为需求描述字典，输出为生成的代码和执行状态。” def can_handle(self, task: str) -> bool: “”“判断任务是否为代码生成相关”“” task_lower = task.lower() # 包含以下关键词则认为可处理 code_keywords = [“code”, “代码”, “编写”, “生成python”, “python代码”] return any(keyword in task_lower for keyword in code_keywords) def run(self, input: dict, context: dict = None) -> dict: “”“执行代码生成逻辑 Args: input: 输入字典，必须包含 key: “requirement”（代码需求描述） context: 上下文字典，可选包含 key: “code_type”（代码类型，如工具类、接口等） Returns: dict: 包含生成的代码、执行状态、备注信息 “”” # 校验输入参数 if “requirement” not in input or not input[“requirement”].strip(): return { “code”: “”, “status”: “failed”, “message”: “输入参数缺失，必须提供 ‘requirement’（代码需求描述）” } # 构建 LLM 提示词（优化提示词，提升代码生成质量） code_type = context.get(“code_type”, “通用Python代码”) if context else “通用Python代码” prompt = f"“” 请生成干净、规范、可运行的生产级{code_type}，满足以下需求： {input[‘requirement’]} 生成要求： 1. 代码格式规范，符合PEP8标准，包含必要的注释（类、方法、关键逻辑）； 2. 避免使用过时语法，兼容Python 3.8+版本； 3. 生成完整可运行代码，包含必要的导入语句、异常处理； 4. 若需求涉及第三方库，需在代码注释中说明需安装的库（如pip install xxx）。 “”" # 调用 LLM 生成代码（此处模拟 LLM 调用，实际可替换为 OpenAI、通义千问等API） # 假设 llm 为已实例化的 LLM 客户端 # code = llm.generate(prompt) # 模拟生成代码（实际场景替换为真实 LLM 调用结果） code = f"“”# 生成的{code_type} import os def generate_example(): “”“根据需求生成的示例代码”“” try: # 需求核心逻辑实现 print(“需求：{input[‘requirement’]}”) return True except Exception as e: print(f"执行异常：{str(e)}“) return False # 测试代码 if __name__ == “__main__”: generate_example() “”” return { “code”: code, “status”: “success”, “message”: “代码生成成功，可直接运行，若有第三方库依赖请参考代码注释安装”, “code_type”: code_type }

👉 升级版（带 Tool + Flow，多步执行）

以下 DebugSkill 串联了“错误分析、方案搜索、代码修复”三个步骤，其中调用了搜索 Tool，具备完整的多步执行逻辑，本质是一个 mini-agent：

python class DebugSkill(Skill): “”“Skill：调试 Python 代码错误，串联错误分析、方案搜索、代码修复三个步骤”“” name = “debugging” description = “用于调试 Python 代码错误，输入错误信息，输出修复后的代码和错误分析，支持调用搜索工具获取解决方案，适用于语法错误、运行时错误等场景。” def can_handle(self, task: str) -> bool: “”“判断任务是否为代码调试相关”“” task_lower = task.lower() return “debug” in task_lower or “错误” in task_lower or “修复代码” in task_lower def run(self, input: dict, context: dict = None) -> dict: “”“执行代码调试逻辑 Args: input: 输入字典，必须包含 key: “error”（错误信息字符串）、“code”（出错代码） context: 上下文字典，可选包含 key: “debug_level”（调试级别，简单/详细） Returns: dict: 包含错误分析、修复方案、修复后代码、执行状态 “”” # 校验输入参数 required_keys = [“error”, “code”] if not all(key in input and input[key].strip() for key in required_keys): return { “fix”: “”, “error_analysis”: “”, “status”: “failed”, “message”: f"输入参数缺失，必须提供 {required_keys} 两个key" } error = input[“error”] code = input[“code”] debug_level = context.get(“debug_level”, “详细”) if context else “详细” # Step 1: 分析错误原因（调用 LLM 实现，模拟逻辑） analysis = self.analyze_error(error, code, debug_level) # Step 2: 搜索解决方案（调用 Tool，此处模拟搜索工具） solutions = self.search_solutions(error) # Step 3: 生成修复代码（调用 LLM 实现，模拟逻辑） fix_code = self.generate_fix_code(code, analysis, solutions) return { “fix”: fix_code, “error_analysis”: analysis, “solutions”: solutions, “status”: “success”, “debug_level”: debug_level } def analyze_error(self, error: str, code: str, debug_level: str) -> str: “”“辅助方法：分析错误原因”“” # 模拟 LLM 错误分析（实际替换为真实 LLM 调用） return f"{debug_level}错误分析：\n错误信息：{error}\n出错代码：{code[:200]}…\n推测原因：语法错误或变量未定义，需检查代码拼写和变量声明" def search_solutions(self, error: str) -> list: “”“辅助方法：调用搜索工具获取解决方案（模拟 Tool 调用）”“” # 模拟搜索工具返回结果 return [ f"解决方案1：检查代码中是否有拼写错误，错误信息 ‘{error}’ 常见于变量未定义", “解决方案2：确保所有导入语句正确，相关依赖库已安装”, “解决方案3：检查代码缩进是否符合PEP8标准，避免缩进错误导致的语法问题” ] def generate_fix_code(self, code: str, analysis: str, solutions: list) -> str: “”“辅助方法：生成修复后的代码”“” # 模拟 LLM 生成修复代码（实际替换为真实 LLM 调用） return f"# 修复后的代码\n{code.replace(‘undefined_var’, ‘defined_var’)} # 修复：变量未定义问题\n\n# 修复说明：\n# {analysis}\n# 参考解决方案：{solutions[0]}"

👉 核心特点：此 Skill 已具备 mini-agent 的能力，可自主完成多步决策和执行，无需 Agent 反复调度。

三、Agent 如何加载 Skill？

Agent 加载 Skill 主要通过“注册表模式”实现，核心是将所有 Skill 注册到统一的注册表中，Agent 根据任务动态匹配并调用对应的 Skill，以下是三种常用加载方式（从简单到高级）。

1️⃣ 最简单：注册表模式（基础版）

通过 SkillRegistry 类管理所有 Skill，提供注册和查询功能，适用于简单 Agent 系统：

python class SkillRegistry: “”“Skill 注册表，用于管理所有注册的 Skill，提供注册和查询功能”“” def __init__(self): # 存储所有注册的 Skill 实例（列表形式，支持多个同类型 Skill） self.skills = [] def register(self, skill: Skill) -> None: “”“注册 Skill 实例 Args: skill: 继承自 Skill 基础类的实例 “”” # 校验 Skill 实例的合法性（必须实现 name、description、can_handle、run 方法） required_attrs = [“name”, “description”, “can_handle”, “run”] if not all(hasattr(skill, attr) for attr in required_attrs): raise ValueError(“注册的 Skill 必须继承自 Skill 基础类，且实现所有必填方法和属性”) # 避免重复注册（根据 name 去重） if not any(s.name == skill.name for s in self.skills): self.skills.append(skill) print(f"Skill 注册成功：{skill.name}“) else: print(f"Skill 已注册：{skill.name}，无需重复注册”) def find_skill(self, task: str) -> Skill

2️⃣ Agent 调度 Skill（基础版调度逻辑）

Agent 通过注册表获取可处理任务的 Skill，并调用其 run 方法执行任务，适用于简单场景：

python class Agent: “”“基础 Agent 类，通过 Skill 注册表调度 Skill 完成任务”“” def __init__(self, skill_registry: SkillRegistry): # 关联 Skill 注册表 self.registry = skill_registry # 初始化 Agent 上下文（存储历史执行记录） self.context = {“history”: []} def run(self, task: str, input_data: dict = None) -> dict: “”“执行任务，调度对应的 Skill Args: task: 任务描述（字符串） input_data: 任务输入数据（结构化字典，传递给 Skill 的 run 方法） Returns: dict: 任务执行结果（来自 Skill 的输出） “”” # 查找可处理该任务的 Skill skill = self.registry.find_skill(task) if not skill: result = { “status”: “failed”, “message”: f"未找到可处理该任务的 Skill，任务：{task}“, “data”: None } else: # 调用 Skill 的 run 方法，传递输入数据和 Agent 上下文 input_data = input_data or {} result = skill.run(input_data, self.context) # 记录历史执行记录（更新上下文） self.context[“history”].append({ “task”: task, “skill”: skill.name, “result”: result, “time”: datetime.datetime.now().strftime(”%Y-%m-%d %H:%M:%S") }) return result

👉 使用示例（基础版）

python import datetime # 导入必要的模块 # 1. 初始化 Skill 注册表 registry = SkillRegistry() # 2. 注册 Skill 实例 registry.register(CodeGenSkill()) registry.register(DebugSkill()) # 3. 初始化 Agent，关联注册表 agent = Agent(registry) # 4. 执行任务（调试代码错误） task = “修复 Python 代码错误” input_data = { “error”: “NameError: name ‘undefined_var’ is not defined”, “code”: “print(undefined_var)” } result = agent.run(task, input_data) # 5. 打印执行结果 print(“任务执行结果：”) print(f"状态：{result[‘status’]}“) print(f"错误分析：{result[‘error_analysis’]}”) print(f"修复后代码：\n{result[‘fix’]}")

3️⃣ 高级：LLM 决策选择 Skill（推荐版）

当存在多个可处理任务的 Skill 时，通过 LLM 进行智能决策，选择最适合的 Skill，适用于复杂 Agent 系统（如多智能体协作、复杂任务拆解）：

python def select_best_skill(task: str, skills: list[Skill], llm) -> Skill

👉 类似实现参考：

• LangGraph Router（通过图结构实现 Skill 路由）
• OpenAI Function Calling Router（通过函数调用实现 Skill 选择）
• CrewAI Role Selector（通过角色分配实现 Skill 调度）

四、Skill 能干什么？

Skill 作为 Agent 的核心能力单元，可根据功能分为 5 大类，覆盖 Agent 常见的所有任务场景，其中组合型 Skill 是实现复杂能力（如 Devin、Cursor）的核心。

🧩 Skill 能力分类（非常关键）

1️⃣ 执行型 Skill（基础能力）

核心功能：执行具体的操作，完成单一或简单组合的任务，类似 Tool 但更高级，具备规范的输入输出和简单的流程控制。

• 写代码、调试代码（如 CodeGenSkill、DebugSkill）
• 调用第三方 API（如调用微信 API 发送消息、调用支付 API 完成支付）
• 执行系统命令（如批量处理文件、启动服务）

👉 特点：侧重“执行”，流程相对固定，可直接复用。

2️⃣ 推理型 Skill（核心能力）

核心功能：基于输入信息进行分析、推理、决策，不直接执行操作，而是输出策略、方案或结论。

• 分析问题（如分析用户需求、分析错误原因）
• 生成策略（如制定任务执行计划、生成营销方案）
• 拆解任务（如将“开发一个网站”拆解为“设计UI、编写后端、部署上线”等子任务）

👉 特点：侧重“思考”，依赖 LLM 的推理能力，是 Agent 智能化的核心。

3️⃣ 组合型 Skill（最强能力）

核心功能：串联多个 Skill（或 Tool），形成复杂的执行流程，完成大型、复杂的任务，是 Devin、Cursor 等产品的核心能力。

python class BuildAppSkill(Skill): “”“组合型 Skill：完成一个简单 Python 应用的开发、测试全流程”“” name = “build_app” description = “串联规划、代码生成、测试三个 Skill，完成 Python 应用的开发全流程，输入为应用需求，输出为测试通过的应用代码和测试报告。” def __init__(self): # 初始化依赖的子 Skill self.planning_skill = PlanningSkill()# 推理型 Skill：任务规划 self.codegen_skill = CodeGenSkill() # 执行型 Skill：代码生成 self.test_skill = TestSkill() # 执行型 Skill：代码测试 def can_handle(self, task: str) -> bool: return “开发应用” in task.lower() or “build app” in task.lower() def run(self, input: dict, context: dict = None) -> dict: # Step 1：调用规划 Skill，生成开发计划 plan = self.planning_skill.run(input, context) if plan[“status”] != “success”: return { “status”: “failed”, “message”: f"应用开发规划失败：{plan[‘message’]}“, “data”: None } # Step 2：调用代码生成 Skill，根据计划生成应用代码 code_input = { “requirement”: input[“requirement”], “plan”: plan[“plan”] } code_result = self.codegen_skill.run(code_input, context) if code_result[“status”] != “success”: return { “status”: “failed”, “message”: f"应用代码生成失败：{code_result[‘message’]}”, “data”: None } # Step 3：调用测试 Skill，对生成的代码进行测试 test_input = { “code”: code_result[“code”], “requirement”: input[“requirement”] } test_result = self.test_skill.run(test_input, context) # 返回全流程结果 return { “status”: “success”, “plan”: plan[“plan”], “app_code”: code_result[“code”], “test_report”: test_result[“report”], “message”: “应用开发全流程完成，测试通过” }

👉 核心特点：可无限嵌套、组合，形成复杂的能力体系，是 Agent 实现“自主完成复杂任务”的关键。

4️⃣ 记忆增强 Skill（辅助能力）

核心功能：管理 Agent 的记忆（短期记忆、长期记忆），提供记忆的存储、检索、更新功能，增强 Agent 的上下文感知能力。

python class MemorySkill(Skill): “”“记忆增强 Skill：管理 Agent 的长期记忆，基于向量数据库实现记忆检索”“” name = “memory_management” description = “用于存储、检索 Agent 的长期记忆，支持根据查询词检索相关历史记录，输入为查询词和记忆数据，输出为检索到的记忆结果。” def __init__(self, vector_db): # 关联向量数据库（用于存储长期记忆，支持语义检索） self.vector_db = vector_db def can_handle(self, task: str) -> bool: task_lower = task.lower() return “记忆” in task_lower or “检索” in task_lower or “历史记录” in task_lower def run(self, input: dict, context: dict = None) -> dict: # 支持两种操作：存储记忆、检索记忆 operation = input.get(“operation”, “search”) if operation == “store”: # 存储记忆：输入需包含 key: “memory_data”（记忆内容） if “memory_data” not in input: return {“status”: “failed”, “message”: “存储记忆需提供 ‘memory_data’”} self.vector_db.add(input[“memory_data”]) return {“status”: “success”, “message”: “记忆存储成功”} elif operation == “search”: # 检索记忆：输入需包含 key: “query”（查询词） if “query” not in input: return {“status”: “failed”, “message”: “检索记忆需提供 ‘query’”} history = self.vector_db.search(input[“query”], top_k=5)# 检索前5条相关记忆 return { “status”: “success”, “memory_results”: history, “count”: len(history) } else: return {“status”: “failed”, “message”: f"不支持的操作：{operation}，仅支持 ‘store’ 和 ‘search’"}

5️⃣ 多 Agent 协作 Skill（高级能力）

核心功能：协调多个 Agent 协同工作，分配任务、汇总结果，完成单一 Agent 无法完成的复杂任务。

python class MultiAgentSkill(Skill): “”“多 Agent 协作 Skill：协调多个 Agent 完成复杂任务”“” name = “multi_agent_collaboration” description = “用于协调多个不同角色的 Agent 协同工作，分配子任务，汇总各 Agent 的执行结果，输出最终任务结果，适用于复杂任务拆解后的多 Agent 协作场景。” def __init__(self, agents: dict): # 存储多个 Agent，key 为 Agent 角色，value 为 Agent 实例 self.agents = agents# 示例：{“code_agent”: 代码开发Agent, “test_agent”: 测试Agent} def can_handle(self, task: str) -> bool: return “多agent” in task.lower() or “协作” in task.lower() or “分工” in task.lower() def run(self, input: dict, context: dict = None) -> dict: # 输入需包含：任务描述、各 Agent 的子任务分配 if “task” not in input or “subtasks” not in input: return {“status”: “failed”, “message”: “需提供 ‘task’（总任务）和 ‘subtasks’（子任务分配）”} subtasks = input[“subtasks”] results = {} # 遍历子任务，分配给对应的 Agent 执行 for agent_role, subtask in subtasks.items(): if agent_role not in self.agents: return {“status”: “failed”, “message”: f"不存在角色为 {agent_role} 的 Agent"} # 调用对应 Agent 执行子任务 agent_result = self.agents[agent_role].run(subtask[“task”], subtask[“input”]) results[agent_role] = agent_result # 汇总所有 Agent 的结果，生成最终报告 final_report = self.summarize_results(input[“task”], results) return { “status”: “success”, “final_report”: final_report, “agent_results”: results } def summarize_results(self, total_task: str, agent_results: dict) -> str: “”“辅助方法：汇总各 Agent 的执行结果，生成最终报告”“” report = f"总任务：{total_task}\n\n各 Agent 执行结果汇总：\n" for agent_role, result in agent_results.items(): status = result[“status”] message = result.get(“message”, “无说明”) report += f"- {agent_role}：状态={status}，说明：{message}\n" report += “\n任务协作完成，所有子任务已执行完毕。” return report

五、Skill 如何节省 Token？（核心重点🔥）

Token 消耗是 Agent 工程化落地的核心痛点之一，尤其是多步任务中，Tool 模式的频繁调用会导致 Token 消耗爆炸，而 Skill 通过“封装”特性，可大幅降低 Token 消耗，以下是具体分析。

❗ Tool 模式的问题（Token 消耗高的根源）

假设一个复杂任务：“帮我写一段 Python 代码 + 调试错误 + 优化代码 + 生成测试用例”

Tool 方式（❌ 高 Token 消耗）

Tool 模式下，Agent 需反复进行“决策-调用-接收结果-再决策”的循环，每一步都需消耗大量 Token：

text LLM 执行流程： 1. 分析任务，决定调用「代码生成 Tool」→ 消耗 Token（提示词 + Tool schema） 2. 调用「代码生成 Tool」，接收返回的代码 → 消耗 Token（Tool 响应内容） 3. 分析代码，决定调用「调试 Tool」→ 消耗 Token（提示词 + Tool schema） 4. 调用「调试 Tool」，接收修复后的代码 → 消耗 Token（Tool 响应内容） 5. 分析修复后的代码，决定调用「优化 Tool」→ 消耗 Token（提示词 + Tool schema） 6. 调用「优化 Tool」，接收优化后的代码 → 消耗 Token（Tool 响应内容） 7. 分析优化后的代码，决定调用「测试用例生成 Tool」→ 消耗 Token（提示词 + Tool schema） 8. 调用「测试用例生成 Tool」，接收测试用例 → 消耗 Token（Tool 响应内容） 9. 汇总所有结果，生成最终回复 → 消耗 Token（提示词 + 结果汇总）

👉 每一步都需消耗的 Token 包括：

• 提示词：告诉 LLM 下一步该做什么、如何调用 Tool
• Tool schema：每次调用都需传递 Tool 的输入输出格式（重复传递，冗余）
• Tool 响应：接收 Tool 的返回结果，需传递给 LLM 进行下一步分析
• 推理过程：LLM 分析结果、决策下一步操作的思考过程

👉 最终 Token 消耗 = 多步重复消耗 + 冗余消耗 = 爆炸式增长 💥

✅ Skill 方式（封装，低 Token 消耗）

Skill 模式下，将“写代码 + 调试 + 优化 + 测试”整个流程封装为一个 Skill，Agent 仅需调用一次 Skill，即可完成所有步骤：

python # Agent 仅需一次调用，即可完成整个复杂任务 result = coding_optimize_test_skill.run(task) # Skill 内部自带完整流程（无需 Agent 反复决策） def run(self, task): # Step1: 写代码（内部调用代码生成逻辑） code = self.generate_code(task) # Step2: 调试错误（内部调用调试逻辑） fixed_code = self.debug_code(code) # Step3: 优化代码（内部调用优化逻辑） optimized_code = self.optimize_code(fixed_code) # Step4: 生成测试用例（内部调用测试生成逻辑） test_case = self.generate_test_case(optimized_code) # 返回最终结果 return { “code”: optimized_code, “test_case”: test_case, “status”: “success” }

👉 对 LLM 来说，仅需处理一次调用：

• 只看到一次 Skill 调用，无需反复决策下一步操作
• 无需重复传递 Tool schema（Skill 内部已封装，无需暴露给 LLM）
• 无需接收中间结果并分析（中间步骤由 Skill 内部处理）
• 链路长度大幅缩短，仅需一次提示词 + 一次结果返回

🔥 本质优化（Token 节省的核心逻辑）

优化点	具体说明	Token 节省效果
减少决策次数	无需多轮 function call 决策，仅需一次 Skill 调用	节省 50%+ 决策相关 Token
减少上下文重复	Tool schema 无需重复传递，Skill 内部封装所有依赖	节省 30%+ 冗余 Token
减少中间输出	中间步骤（如调试结果、优化过程）由 Skill 内部处理，不传递给 LLM	节省 20%+ 中间结果传递 Token
减少链路长度	从“多步调用”简化为“一步调用”，缩短 LLM 处理链路	节省 10%+ 链路相关 Token

👉 一个真实对比（量化 Token 节省效果）

Tool 模式（复杂任务）

text Step1：调用代码生成 Tool → 500 tokens（提示词 + schema + 响应） Step2：调用调试 Tool → 600 tokens（提示词 + schema + 响应） Step3：调用优化 Tool → 700 tokens（提示词 + schema + 响应） Step4：调用测试生成 Tool → 600 tokens（提示词 + schema + 响应） Step5：汇总结果 → 400 tokens（提示词 + 汇总） Total Token = 500 + 600 + 700 + 600 + 400 = 2800 tokens

Skill 模式（相同复杂任务）

text Single call：调用 CodingOptimizeTestSkill → 1100 tokens（提示词 + 最终结果） Total Token = 1100 tokens

👉 节省 Token 数量：2800 - 1100 = 1700 tokens，节省比例达 60%+，任务越复杂，Skill 模式的 Token 节省效果越明显。

六、Skill 的进阶设计（高手部分🔥）

基础 Skill 仅能满足简单场景需求，对于企业级 Agent 系统，需对 Skill 进行进阶设计，实现可编排、带状态、分层级的能力体系，以下是三种核心进阶方向。

1️⃣ Skill = 可编排 DAG（流程可视化）

将 Skill 的执行流程设计为有向无环图（DAG），支持可视化编排，可灵活调整步骤顺序、条件分支，适用于复杂流程的 Skill 设计（如数据处理、业务流程自动化）。

python class SkillGraph: “”“可编排 DAG 型 Skill，支持步骤可视化和灵活编排”“” def __init__(self, name: str): self.name = name self.nodes = []# 节点：每个节点对应一个子 Skill 或操作 self.edges = []# 边：定义节点之间的执行顺序（有向无环） def add_node(self, node_id: str, skill: Skill, description: str = “”) -> None: “”“添加节点（子 Skill）”“” self.nodes.append({ “node_id”: node_id, “skill”: skill, “description”: description, “status”: “pending”# 节点状态：pending/processing/success/failed }) def add_edge(self, from_node_id: str, to_node_id: str, condition: str = “success”) -> None: “”“添加边（执行顺序），支持条件分支”“” # condition：节点执行成功（success）或失败（failed）时触发下一个节点 self.edges.append({ “from”: from_node_id, “to”: to_node_id, “condition”: condition }) def run(self, input_data: dict, context: dict = None) -> dict: “”“执行 DAG 流程，按节点顺序和条件分支执行”“” # 简化实现：按节点添加顺序执行，实际可根据 edges 动态调整 results = {} for node in self.nodes: node_id = node[“node_id”] skill = node[“skill”] try: node[“status”] = “processing” # 执行当前节点的 Skill result = skill.run(input_data, context) results[node_id] = result node[“status”] = “success” # 更新输入数据（将当前节点结果传递给下一个节点） input_data[f"node_{node_id}_result"] = result except Exception as e: node[“status”] = “failed” results[node_id] = {“status”: “failed”, “message”: str(e)} # 若节点执行失败，根据边的条件决定是否继续执行 if not any(edge[“from”] == node_id and edge[“condition”] == “failed” for edge in self.edges): break return { “skill_graph_name”: self.name, “node_status”: {node[“node_id”]: node[“status”] for node in self.nodes}, “results”: results, “status”: “success” if all(node[“status”] == “success” for node in self.nodes) else “failed” }

👉 类似实现参考：

• LangGraph（基于图结构的 Agent 框架，天然支持 Skill 编排）
• Airflow（数据流程编排工具，可用于 Skill 流程管理）
• DAG Engine（自定义 DAG 引擎，实现 Skill 步骤编排）

2️⃣ Skill 带状态（Stateful Skill）

基础 Skill 是无状态的（每次调用独立，不保留历史信息），而带状态的 Skill 可保留执行过程中的状态信息（如中间结果、执行次数、配置参数），适用于需要连续执行、状态维护的场景（如长期对话、持续监控）。

python class StatefulSkill(Skill): “”“带状态的 Skill，保留执行过程中的状态信息”“” name = “stateful_skill” description = “带状态的 Skill，可保留执行次数、中间结果等状态信息，支持连续执行和状态更新。” def __init__(self): # 初始化状态信息（可根据需求扩展） self.state = { “execution_count”: 0,# 执行次数 “intermediate_results”: [],# 中间结果 “last_execution_time”: None,# 最后执行时间 “config”: {“threshold”: 0.8}# 配置参数 } def can_handle(self, task: str) -> bool: return “状态” in task.lower() or “连续执行” in task.lower() def run(self, input: dict, context: dict = None) -> dict: # 更新状态：执行次数 +1 self.state[“execution_count”] += 1 # 更新最后执行时间 self.state[“last_execution_time”] = datetime.datetime.now().strftime(“%Y-%m-%d %H:%M:%S”) # 执行核心逻辑（示例：根据输入计算得分，判断是否达到阈值） score = input.get(“score”, 0) threshold = self.state[“config”][“threshold”] result = “达标” if score >= threshold else “未达标” # 保存中间结果 self.state[“intermediate_results”].append({ “input_score”: score, “result”: result, “time”: self.state[“last_execution_time”] }) # 返回结果和当前状态 return { “status”: “success”, “result”: result, “current_state”: self.state.copy()# 返回状态副本，避免外部修改 }

👉 核心特点：状态信息保存在 Skill 实例中，每次调用都会更新状态，可用于连续任务、长期监控等场景。

3️⃣ Skill 层级（Hierarchy，分层架构）

将 Skill 分为不同层级，形成“Agent → 高级 Skill → 子 Skill → Tool”的三层架构，实现能力的分层管理和复用，适用于企业级 Agent 系统（如多业务线、多场景复用）。

text Agent（决策层） ├── 高级 Skill（业务能力层） │ ├── 子 Skill（基础能力层） │ └── Tool（执行层） ├── 高级 Skill（业务能力层） │ ├── 子 Skill（基础能力层） │ └── Tool（执行层） └── 高级 Skill（业务能力层） ├── 子 Skill（基础能力层） └── Tool（执行层）

👉 三层架构详细说明：

• Agent（决策层）：负责全局决策，根据任务选择对应的高级 Skill，不直接执行具体操作。
• 高级 Skill（业务能力层）：对应具体的业务场景（如“用户需求分析”“产品方案生成”），由多个子 Skill 组合而成。
• 子 Skill（基础能力层）：对应具体的基础能力（如“文本总结”“数据统计”），可复用在多个高级 Skill 中。
• Tool（执行层）：最底层的原子操作（如“搜索”“文件读写”），为子 Skill 提供基础支持。

👉 优势：分层管理，降低耦合度，基础 Skill 可跨业务复用，高级 Skill 可灵活调整，便于维护和扩展。

七、最终架构（推荐，企业级落地参考）

结合上述设计，推荐以下 Agent + Skill 架构，兼顾灵活性、可扩展性和 Token 效率，接近 Cursor / Devin 等产品的核心架构：

text ┌──────────────┐ │ Agent │ │ (Planner) │# 决策层：全局任务规划、Skill 选择 └──────┬───────┘ │ ┌────────▼────────┐ │Skill Router │# 路由层：根据 Agent 决策，调度对应的 Skill └────────┬────────┘ │ ┌────────────────┼────────────────┐ │ │ │ ┌────▼────┐ ┌────▼────┐ ┌────▼────┐ │ Coding│ │ Debug │ │ Research│# 业务能力层：高级 Skill │ Skill │

普通人如何抓住AI大模型的风口？

领取方式在文末

为什么要学习大模型？

目前AI大模型的技术岗位与能力培养随着人工智能技术的迅速发展和应用 ， 大模型作为其中的重要组成部分 ， 正逐渐成为推动人工智能发展的重要引擎 。大模型以其强大的数据处理和模式识别能力， 广泛应用于自然语言处理 、计算机视觉 、 智能推荐等领域 ，为各行各业带来了革命性的改变和机遇 。

目前，开源人工智能大模型已应用于医疗、政务、法律、汽车、娱乐、金融、互联网、教育、制造业、企业服务等多个场景，其中，应用于金融、企业服务、制造业和法律领域的大模型在本次调研中占比超过 30%。

随着AI大模型技术的迅速发展，相关岗位的需求也日益增加。大模型产业链催生了一批高薪新职业：

人工智能大潮已来，不加入就可能被淘汰。如果你是技术人，尤其是互联网从业者，现在就开始学习AI大模型技术，真的是给你的人生一个重要建议！

最后

只要你真心想学习AI大模型技术，这份精心整理的学习资料我愿意无偿分享给你，但是想学技术去乱搞的人别来找我！

在当前这个人工智能高速发展的时代，AI大模型正在深刻改变各行各业。我国对高水平AI人才的需求也日益增长，真正懂技术、能落地的人才依旧紧缺。我也希望通过这份资料，能够帮助更多有志于AI领域的朋友入门并深入学习。

真诚无偿分享！！！
vx扫描下方二维码即可
加上后会一个个给大家发
【附赠一节免费的直播讲座，技术大佬带你学习大模型的相关知识、学习思路、就业前景以及怎么结合当前的工作发展方向等，欢迎大家~】

大模型全套学习资料展示

自我们与MoPaaS魔泊云合作以来，我们不断打磨课程体系与技术内容，在细节上精益求精，同时在技术层面也新增了许多前沿且实用的内容，力求为大家带来更系统、更实战、更落地的大模型学习体验。

希望这份系统、实用的大模型学习路径，能够帮助你从零入门，进阶到实战，真正掌握AI时代的核心技能！

01 教学内容

• 从零到精通完整闭环：【基础理论 →RAG开发 → Agent设计 → 模型微调与私有化部署调→热门技术】5大模块，内容比传统教材更贴近企业实战！

• 大量真实项目案例： 带你亲自上手搞数据清洗、模型调优这些硬核操作，把课本知识变成真本事‌！

02适学人群

应届毕业生‌： 无工作经验但想要系统学习AI大模型技术，期待通过实战项目掌握核心技术。

零基础转型‌： 非技术背景但关注AI应用场景，计划通过低代码工具实现“AI+行业”跨界‌。

业务赋能突破瓶颈： 传统开发者（Java/前端等）学习Transformer架构与LangChain框架，向AI全栈工程师转型‌。

vx扫描下方二维码即可
【附赠一节免费的直播讲座，技术大佬带你学习大模型的相关知识、学习思路、就业前景以及怎么结合当前的工作发展方向等，欢迎大家~】

本教程比较珍贵，仅限大家自行学习，不要传播！更严禁商用！

03 入门到进阶学习路线图

大模型学习路线图，整体分为5个大的阶段：

04 视频和书籍PDF合集

从0到掌握主流大模型技术视频教程（涵盖模型训练、微调、RAG、LangChain、Agent开发等实战方向）

新手必备的大模型学习PDF书单来了！全是硬核知识，帮你少走弯路（不吹牛，真有用）

05 行业报告+白皮书合集

收集70+报告与白皮书，了解行业最新动态！

06 90+份面试题/经验

AI大模型岗位面试经验总结（谁学技术不是为了赚$呢，找个好的岗位很重要）

07 deepseek部署包+技巧大全

由于篇幅有限

只展示部分资料

并且还在持续更新中…

真诚无偿分享！！！
vx扫描下方二维码即可
加上后会一个个给大家发
【附赠一节免费的直播讲座，技术大佬带你学习大模型的相关知识、学习思路、就业前景以及怎么结合当前的工作发展方向等，欢迎大家~】