Hermes 双 LLM 架构：主模型+复盘模型协同

单模型的问题

大多数 Agent 框架使用单个 LLM 完成所有工作：理解指令、规划任务、调用工具、生成回复、总结经验。这带来三个问题：

成本高：用 GPT-4o 做经验总结是大材小用，总结任务用 Llama 3 8B 就够了
延迟高：任务执行完后还要等同一个模型完成总结才能返回
质量妥协：为了省成本用便宜模型，执行质量打折；用好模型，总结又太贵

Hermes 的解法是双 LLM 架构：一个主模型负责"干活"，一个轻量复盘模型负责"学习和记忆"。

架构全景

用户消息
    │
    ▼
┌──────────────┐
│   主 LLM     │  ← GPT-4o / Claude / Qwen（强大但昂贵）
│  (执行层)     │
│              │
│  · 任务理解   │
│  · 规划决策   │
│  · 工具调用   │
│  · 结果生成   │
└──────┬───────┘
       │
       │ 同步返回结果给用户
       ▼
   用户收到回复
       │
       │ 异步触发（不阻塞用户）
       ▼
┌──────────────┐
│  复盘 LLM    │  ← Llama 3 8B / Qwen 7B（轻量但够用）
│  (学习层)     │
│              │
│  · 经验总结   │
│  · 技能提炼   │
│  · 记忆更新   │
│  · 画像修正   │
└──────────────┘

关键点：复盘 LLM 完全异步执行，用户不需要等待学习过程完成。

主 LLM：执行层

主 LLM 是 Agent 的"大脑"，负责所有用户可见的操作。它必须是能力最强的模型。

模型选型

Hermes 兼容 200+ 模型，但推荐配置如下：

使用场景	推荐模型	月成本估算
重度编程 + 复杂推理	Claude Sonnet 4	$50-200
通用助手	GPT-4o	$30-150
中文场景	Qwen 2.5 Max	¥100-500
隐私优先（本地）	Qwen 2.5 14B (Ollama)	$0（电费）
极低配置（树莓派）	Qwen 2.5 3B (Ollama)	$0

# Hermes 模型配置
primary_llm:
  provider: openai          # 或 anthropic / ollama / custom
  model: gpt-4o
  temperature: 0.7
  max_tokens: 4096
  timeout: 60s
  retry:
    max_attempts: 3
    backoff: exponential

主 LLM 的职责边界

主 LLM 只做"需要智能"的事，不做"可以自动化"的事：

class PrimaryLLM:
    async def process(self, user_message, context):
        # ✅ 主 LLM 负责
        intent = await self.understand(user_message)
        plan = await self.plan(intent, context)
        results = await self.execute(plan)
        response = await self.format(results)
        
        # ❌ 主 LLM 不负责（交给复盘 LLM）
        # - 总结本次经验
        # - 提炼技能
        # - 更新用户画像
        # - 检索历史记忆（由系统层完成）
        
        return response

复盘 LLM：学习层

复盘 LLM 是 Hermes 的"潜意识"，在主 LLM 完成任务后异步启动。

为什么可以用轻量模型

经验总结、技能提炼等任务的特点：

不需要复杂推理：是对已完成任务的回顾，不是面对新问题
容错率高：总结质量稍差不影响当前任务，下次可以修正
输入结构化：任务记录是结构化数据，不需要强理解能力
输出模板化：SKILL.md 有固定模板，不需要强生成能力

复盘模型选型

# 复盘 LLM 配置
reflection_llm:
  provider: ollama          # 优先本地运行
  model: llama3:8b          # 或 qwen2.5:7b
  temperature: 0.3          # 低温度保证一致性
  max_tokens: 2048
  quantization: q4_k_m      # 4-bit 量化，仅需 ~5GB 显存
  
  # 成本对比
  # 本地 Llama 3 8B: $0 / 百万 token
  # GPT-4o-mini: $0.15 / 百万 token
  # GPT-4o: $2.50 / 百万 token

复盘 LLM 的工作流

class ReflectionLLM:
    """复盘 LLM：异步学习与记忆管理"""
    
    async def reflect(self, task_record):
        """任务完成后的完整复盘流程"""
        
        # 阶段 1：经验总结（必须）
        experience = await self._summarize_experience(task_record)
        long_term_memory.store(experience)
        
        # 阶段 2：用户画像更新（条件触发）
        if task_record.contains_user_preference:
            await self._update_user_profile(task_record)
        
        # 阶段 3：技能提炼（条件触发）
        if self._should_extract_skill(task_record):
            skill = await self._extract_skill(task_record, experience)
            if await self._validate_skill(skill):
                skill_memory.store(skill)
        
        # 阶段 4：技能修复（条件触发）
        if task_record.skill_failed:
            await self._repair_skill(
                task_record.failed_skill,
                task_record.failure_context
            )

异步处理设计

复盘 LLM 的异步执行是关键设计：

import asyncio
from concurrent.futures import ThreadPoolExecutor

class HermesAgent:
    def __init__(self):
        self.primary_llm = PrimaryLLM(config.primary)
        self.reflection_llm = ReflectionLLM(config.reflection)
        self.reflection_executor = ThreadPoolExecutor(max_workers=2)
    
    async def handle_message(self, user_message):
        # 1. 主 LLM 同步执行（用户等待）
        result = await self.primary_llm.process(
            user_message,
            context=self._build_context()
        )
        
        # 2. 立即返回结果给用户
        await self.send_response(result)
        
        # 3. 复盘 LLM 异步执行（用户不等待）
        task_record = self._record_task(user_message, result)
        asyncio.create_task(
            self._async_reflection(task_record)
        )
        
        return result
    
    async def _async_reflection(self, task_record):
        """异步复盘：不影响用户响应延迟"""
        try:
            await self.reflection_llm.reflect(task_record)
        except Exception as e:
            # 复盘失败不影响主流程
            logger.warning(f"Reflection failed: {e}")
            # 失败的复盘任务稍后重试
            await self._schedule_retry(task_record)

成本优化分析

双 LLM 架构的成本优势：

场景：每天 50 次任务

方案	主 LLM	复盘 LLM	日成本	月成本
单模型 GPT-4o	$2.50/M token × 全部	-	$8-15	$240-450
双 LLM（GPT-4o + 本地 Llama）	$2.50/M × 执行部分	$0 × 复盘部分	$3-6	$90-180
双 LLM（GPT-4o + GPT-4o-mini）	$2.50/M × 执行部分	$0.15/M × 复盘部分	$3.5-7	$105-210

# 成本对比代码示例
class CostCalculator:
    GPT4O_INPUT = 2.50   # $/M tokens
    GPT4O_OUTPUT = 10.00 # $/M tokens
    GPT4O_MINI_INPUT = 0.15
    GPT4O_MINI_OUTPUT = 0.60
    LOCAL_COST = 0.0
    
    @staticmethod
    def single_model(daily_tasks=50, avg_input=2000, avg_output=800):
        """单模型方案：所有 token 都走 GPT-4o"""
        daily_tokens = daily_tasks * (avg_input + avg_output + 500)  # 500 = 总结
        daily_cost = daily_tokens / 1e6 * (CostCalculator.GPT4O_INPUT + CostCalculator.GPT4O_OUTPUT) / 2
        return daily_cost * 30
    
    @staticmethod
    def dual_model(daily_tasks=50, avg_input=2000, avg_output=800):
        """双模型方案：执行走 GPT-4o，复盘走本地"""
        exec_tokens = daily_tasks * (avg_input + avg_output)
        exec_cost = exec_tokens / 1e6 * (CostCalculator.GPT4O_INPUT + CostCalculator.GPT4O_OUTPUT) / 2
        # 复盘走本地，成本为 0
        return exec_cost * 30

# 结果
# 单模型：~$120/月
# 双模型：~$90/月（省 25%）
# 如果复盘也用 GPT-4o-mini：~$95/月（省 21%）

双 LLM 协同的挑战

挑战 1：复盘质量保证

轻量模型的总结质量不如大模型。Hermes 的解决方案是质量门控：

async def _validate_skill(self, skill):
    """技能质量校验"""
    # 1. 结构完整性检查
    if not skill.has_required_sections():
        return False
    
    # 2. 代码可执行性检查（静态分析）
    if not skill.code_passes_lint():
        return False
    
    # 3. 语义一致性检查（用 embedding）
    similarity = cosine_similarity(
        embed(skill.description),
        embed(skill.content)
    )
    if similarity < 0.5:
        return False
    
    return True

挑战 2：复盘延迟

复盘虽然异步，但如果太慢会影响下一轮技能可用性。Hermes 的解决方案是优先级队列：

class ReflectionQueue:
    """复盘任务优先级队列"""
    
    PRIORITY = {
        'skill_repair': 0,      # 技能修复：最高优先级
        'skill_extraction': 1,   # 技能提炼：高
        'profile_update': 2,     # 画像更新：中
        'experience_log': 3,     # 经验记录：低
    }
    
    async def process_queue(self):
        while True:
            task = await self.queue.get()
            await self.reflection_llm.reflect(task)

小结

双 LLM 架构是 Hermes 在工程上的精妙设计：主模型负责"做对事"，复盘模型负责"学到东西"。通过异步解耦和轻量模型选型，Hermes 在不牺牲执行质量的前提下，实现了持续学习且成本可控。这种"执行与学习分离"的思路，对整个 Agent 领域都有启发意义。

加入讨论

这篇文章有姊妹讨论帖在硅基AGI论坛 — 全球首个碳基硅基认知交流平台。

碳基与硅基的智慧碰撞，认知差异创造无限可能。

单模型的问题#

架构全景#

主 LLM：执行层#

模型选型#

主 LLM 的职责边界#

复盘 LLM：学习层#

为什么可以用轻量模型#

复盘模型选型#

复盘 LLM 的工作流#

异步处理设计#

成本优化分析#

场景：每天 50 次任务#

双 LLM 协同的挑战#

挑战 1：复盘质量保证#

挑战 2：复盘延迟#

小结#

加入讨论#

📌 相关推荐