OpenClaw 节省 90% Token 的完整优化指南：从输入、调用到模型策略

很多人刚开始用 OpenClaw 的时候，都会遇到一个问题：Token 消耗得特别快。明明只是聊了几轮，账单就蹭蹭往上涨。

为什么会这样呢？

其实，要理解 Token 消耗，我们可以用一个简单的公式来理解：

Token消耗 = (输入 + 输出) × 调用次数 × 模型价格

其中，这里的输入输出就是你的上下文，模型价格就是不同模型的计费标准，调用次数就是调用大模型的次数。

所以下面我们用这个公式来分析一下，OpenClaw 为什么会这么消耗 Token，以及我们如何解决这个问题。

输入：看不见的大头

很多人以为，Token 主要花在 AI 的回复上。但实际上，输入才是真正的大头。

OpenClaw 的设计哲学是无状态到有状态的转变，为了让 Agent 像人类一样记住一切，框架每次都会默认将完整对话历史发送出去。

也就是你每次和 OpenClaw 对话，它都会发送以下这些内容：

System Prompt（系统提示词 + 自定义）：大约 3,000-10,000 tokens
Tool Schema（工具定义）：约 8,000 tokens
Workspace 文件（OpenClaw 会自动注入这些文件，如果存在的话）
AGENTS.md
SOUL.md
TOOLS.md
IDENTITY.md
USER.md
HEARTBEAT.md
MEMORY.md（可选）
如果启用了 Memory Search，还会检索相关的每日记忆文件（memory/YYYY-MM-DD.md）
历史对话：也就是之前的聊天记录

加起来，一次请求的输入可能就有 2-3 万 tokens。如果你聊了 10 轮，那就是 20-30 万 tokens 的输入。

那怎么优化输入？

1. 精简 Workspace 文件（最简单有效）

OpenClaw 的 Workspace 文件每次对话都会注入，是隐形的 Token 大户。这些文件包括 MEMORY.md（长期精选的记忆）、memory/YYYY-MM-DD.md（每天自动生成的日志）、AGENTS.md（Agent 配置）、SOUL.md（性格文件）、TOOLS.md（工具配置）等。

很多人刚开始用的时候，这些文件都是默认配置，里面有大量用不到的功能说明。比如 AGENTS.md 里可能有群聊规则、TTS 配置、各种你根本不用的功能，这些都在白白消耗 tokens。

精简这些文件是性价比最高的优化。直接用提示词让 AI 帮你：

帮我精简 OpenClaw 的上下文文件以节约 token。具体包括：

AGENTS.md 删掉不需要的部分（群聊规则、TTS、不用的功能），压缩到 800 tokens 以内

SOUL.md 精简为简洁要点，300-500 tokens

MEMORY.md 清理过期信息，控制在 2000 tokens 以内

检查 workspaceFiles 配置，移除不必要的注入文件

定期清理 memory/YYYY-MM-DD.md 中的过期日志

经验法则：每减少 1000 tokens 注入，按每天 100 次调用 Opus 算，月省约 $45。

2. 启用 Prompt Caching

Prompt Caching 可以缓存重复的输入内容，能节约 90% 的输入成本。

工作原理：

第一次请求：10,000 tokens 输入，正常计费
第二次请求：100 tokens 新内容 + 10,000 tokens 缓存
100 tokens 正常计费
10,000 tokens 按缓存读取计费（便宜 10 倍）

配置方法：

{
  "models": {
    "anthropic/claude-opus-4-6": {
      "params": {
        "cacheRetention": "long",
        "maxTokens": 65536
      }
    }
  }
}

3. 配置 Heartbeat 保持缓存温暖

Prompt Caching 的缓存时间是 1 小时。如果超过 1 小时没有对话，缓存就会过期，下次对话需要重新缓存（cache write 成本更高）。

Heartbeat 机制可以定期发送心跳，保持缓存不过期：

{
  "heartbeat": {
    "every": "55 分钟",
    "target": "最后",
    "model": "minimax/MiniMax-M2.5"
  }
}

为什么是 55 分钟？因为缓存时间是 1 小时，55 分钟发一次心跳，可以保持缓存温暖。虽然 Heartbeat 会增加调用次数，但避免了重新缓存的成本，整体是划算的。

注意：Heartbeat 可以使用免费/轻量模型，成本更低。

4. 使用 Context Pruning 自动修剪

跟 OpenClaw 聊了一整天，到晚上的时候发现它开始变慢，或者突然说上下文太长了？这是因为历史消息一直在累积，从早上到晚上可能已经积累了几万 tokens 的对话历史。

Context Pruning 就是用来解决这个问题的。它会自动移除旧的对话内容，保持上下文在合理范围内。配合 Prompt Caching 使用效果更好：

{
  "上下文令牌数": 200000,
  "contextPruning": {
    "mode": "cache-ttl",
    "ttl": "55m"
  }
}

这个配置的意思是：上下文窗口最大 200K tokens，保留 55 分钟内的对话（配合 Heartbeat 和 Prompt Caching 的 1 小时缓存）。超过 55 分钟的旧对话会被自动移除，但不影响缓存的使用。

5. 使用 Compaction 压缩历史

有时候你需要跟 OpenClaw 进行长时间的深度对话，比如一起完成一个复杂的项目，可能要聊几个小时甚至几天。这种情况下，即使有 Context Pruning，对话历史还是会越来越长，最终超出限制。

Compaction 可以把长对话压缩成摘要。它不是简单地删除旧对话，是让 AI 把重要信息提炼出来，保存到 Memory 文件中，然后再清理历史。这样既节约了 tokens，又不会丢失重要信息。

{
  "压缩": {
    "模式": "安全防护",
    "保留令牌下限": 24000,
    "内存刷新": {
      "启用": true,
      "软阈值令牌数": 6000,
      "systemPrompt": "会话即将压缩。立即存储持久记忆。",
      "prompt": "将任何需持久保存的笔记写入 memory/YYYY-MM-DD.md 文件；若无内容存储则回复 NO_REPLY。"
    }
  }
}

memoryFlush 的作用是：在压缩前，自动提醒 AI 保存重要信息到 Memory 文件。这样你就不用担心压缩后丢失重要的讨论内容了。

你也可以在对话中手动触发压缩：

/紧凑
/紧凑聚焦于决策和待解决问题

6. 使用子 Agent 隔离上下文

当你需要让 OpenClaw 并发处理多个独立任务时，比如同时搜索 10 个文件、运行 5 个测试、检查 3 个 API，如果都在主 Agent 里串行执行，不仅慢，而且每个操作都会累积到主 Agent 的上下文中。

子 Agent（Sub-Agent）的核心优势是：每个子 Agent 有独立的上下文，不会继承主 Agent 的完整对话历史。这意味着你可以避免主模型的上下文长度爆炸，变相缩减主模型的上下文，而且子任务可以使用便宜的模型。

{
  "子代理": {
    "模型": "minimax/MiniMax-M2.5",
    "最大并发数": 12,
    "归档等待时间（分钟）": 60
  }
}

使用场景：

需要并发处理多个独立任务（如同时搜索多个文件）
需要并行执行的测试或检查
简单的信息收集任务

子 Agent 的工作原理：每个子 Agent 在独立的 session 中运行，有自己的 token 使用统计，不会继承主 Agent 的对话历史，完成后将结果返回给主 Agent。

这样，主任务用高性能模型保证质量，子任务用免费模型节省成本，同时避免上下文爆炸。

7. 启用 Memory Search 精准检索

OpenClaw 用久了，MEMORY.md 和每天的 memory/YYYY-MM-DD.md 文件会越来越大。传统方式是每次对话都读取整个文件，但你想想，一个几千行的 MEMORY.md，可能有 5000-10000 tokens，但 AI 真正需要的可能只是其中几段相关的内容。

Memory Search 可以根据当前对话内容，只检索相关的 Memory 片段（约 400 tokens 的块），而不是读取整个文件。就像你在图书馆找书，不需要把整个书架的书都搬出来，只需要找到相关的那几本。

{
  "内存搜索": {
    "provider": "local",
    "cache": {
      "enabled": true,
      "maxEntries": 50000
    }
  }
}

Memory Search 的工作原理： 将 MEMORY.md 和 memory/*/.md 分成约 400 tokens 的块（有 80 token 重叠），根据当前对话进行语义检索，只返回相关片段（约 700 字符），而不是整个文件，大幅节约输入 tokens。

Provider 选择：

local（本地嵌入，零成本，适合记忆文件不多的情况）
openai（使用 OpenAI 嵌入模型，质量更高）
voyage（使用 Voyage AI，每账号 2 亿 token 免费）
qmd（使用 qmd 作为 backend，见下文）

8. 使用 qmd 进一步减少上下文（进阶）

如果你有大量文档需要检索，或者想要更强大的语义搜索能力，可以使用 qmd 作为 memory backend。

qmd 的核心价值：精准检索，只返回相关段落，而不是读取整个文件。

传统方式：

Agent 查资料时默认 "读全文"
一个 500 行文件 3000-5000 tokens
但 Agent 只需要其中 10 行
90% 的 input token 被浪费了

qmd 方式：

建立全文 + 向量索引
Agent 精准定位段落
只读取需要的 10-30 行
节约 90% tokens

安装和配置：

# 安装 qmd
npm install -g https://github.com/tobi/qmd

# 为工作目录建立索引
cd ~/.openclaw/workspace
qmd collection add . --name main-workspace --mask "**/*.md"

# 生成向量嵌入
qmd embed

配置 OpenClaw 使用 qmd 作为记忆后端：

{
  "memory": {
    "backend": "qmd",
    "citations": "auto",
    "qmd": {
      "includeDefaultMemory": true,
      "update": {
        "interval": "5m",
        "debounceMs": 15000
      },
      "limits": {
        "maxResults": 8,
        "timeoutMs": 5000
      },
      "paths": [
        {
          "name": "main-workspace",
          "path": "/home/user/.openclaw/workspace",
          "pattern": "**/*.md"
        },
        {
          "name": "obsidian-kb",
          "path": "/path/to/knowledge-base",
          "pattern": "**/*.md"
        }
      ]
    }
  }
}

qmd 的优势：

完全本地运行，零 API 成本
93% 准确率（hybrid search：向量 + 全文）
自动索引 MEMORY.md 和 memory/*/.md（includeDefaultMemory: true）
可以添加额外的知识库路径（如 Obsidian）
自动更新索引（每 5 分钟）

与 Memory Search 的区别：

记忆搜索是功能（使用不同的提供者：本地/OpenAI/Voyage）
qmd 可以作为记忆搜索的后端
qmd 的能力更强：可以索引额外的路径，不仅仅是 MEMORY.md

实测效果：每次查资料从 15000 tokens 降到 1500 tokens，减少 90%。

调用优化：减少不必要的调用

每次对话都是一次 API 调用。虽然我们无法完全避免调用，但可以通过优化来减少不必要的调用。

1. 优化 Cron 任务

Cron 任务每次触发都是一次完整的对话调用，会重新注入全部上下文。一个每 15 分钟跑的 cron，一天 96 次，Opus 下一天可能花费 $10-20。

使用提示词优化：

帮我优化 OpenClaw 的 cron 任务以节约 token。请：

列出所有 cron 任务及其频率和模型

把所有非创作类任务降级为 Sonnet 或免费模型

合并同时间段的任务（比如多个检查合为一个）

降低不必要的高频率（系统检查从 10 分钟改为 30 分钟）

配置 delivery 为按需通知，正常时不发消息

核心原则：不是越频繁越好，大多数 "实时" 需求是假需求。合并 5 个独立检查为 1 次调用，可以省下 75% 上下文注入成本。

2. 优化 Heartbeat 频率

Heartbeat 虽然能保持缓存温暖，但它本身也是一次 API 调用。如果你设置得太频繁，比如每 10 分钟一次，一天就是 144 次调用。即使用免费模型，也会产生不必要的开销。

可以通过以下方式优化：

设置工作时间间隔为 45-60 分钟
深夜 23:00-08:00 设为静默期（反正你也在睡觉）
精简 HEARTBEAT.md 到最少行数
把分散的检查任务合并到 heartbeat 批量执行

{
  "heartbeat": {
    "every": "55m",
    "target": "last",
    "model": "minimax/MiniMax-M2.5",
    "quiet": {
      "start": "23:00",
      "end": "08:00"
    }
  }
}

模型选择：平衡性能和成本

不同模型的价格差距太大，特别是 Claude 模型，价格较高，所以尽可能的不要一直主模型设置为 Claude Opus。

策略1：日常 Sonnet，关键 Opus（手动切换）

Sonnet 定价约 Opus 的 1/5，但是 80% 日常任务完全够用。所以可以保持这样的配置，然后再需要的时候进行切换。

如何切换模型： 在对话中使用 /model 命令：

/model sonnet # 切换到 Sonnet
/model opus # 切换到 Opus
/model haiku # 切换到 Haiku
/model gemini # 切换到 Gemini

你也可以配置模型别名：

{
  "agents": {
    "defaults": {
      "models": {
        "anthropic/claude-opus-4-6": {
          "alias": "opus"
        },
        "anthropic/claude-sonnet-4-5": {
          "alias": "sonnet"
        }
      }
    }
  }
}

然后根据不同场景进行切换：

Opus 场景：长文写作、复杂代码、多步推理、创意任务
Sonnet 场景：日常闲聊、简单问答、cron 检查、heartbeat、文件操作、翻译

策略2：基于频道/分组的差异化配置

在 Discord 或 Telegram 等平台上，可以针对不同的频道或分组设置不同的模型：

代码频道：使用高性能模型（Claude Opus 4.6、GPT-5.3）
适合复杂的代码任务
日常聊天频道：使用便宜模型（MiniMax、Gemini Flash）
适合简单问答和闲聊
创作频道：使用 Claude Opus
适合长文写作和创意任务

通过这种方式，我们可以更有效地控制成本。

免费模型和订阅计划

如果你想进一步降低成本，可以考虑：

MiniMax M2.5、智谱 GLM
Coding Plan：针对开发者的订阅计划，性价比很高，不用担心用量问题
各平台的免费、低价模型：在一些小型任务上使用免费低价的模型，同样能完成任务，价格可以更低，不过一定要注意稳定性。

完整的优化配置

基于上面的分析，这里是一套完整的优化配置。

参考配置文件（~/.openclaw/openclaw.json）：

{
  "agents": {
    "defaults": {
      "model": {
        "primary": "anthropic/claude-sonnet-4-5",
        "fallbacks": [
          "minimax/MiniMax-M2.5",
          "google/gemini-2.0-flash-exp"
        ]
      },
      "models": {
        "anthropic/claude-opus-4-6": {
          "alias": "opus",
          "params": {
            "maxTokens": 65536,
            "cacheRetention": "long"
          }
        },
        "anthropic/claude-sonnet-4-5-20250929": {
          "alias": "sonnet",
          "params": {
            "maxTokens": 16384,
            "cacheRetention": "long"
          }
        },
        "anthropic/claude-haiku-4-5-20251001": {
          "alias": "haiku",
          "params": {
            "maxTokens": 16384,
            "cacheRetention": "long"
          }
        }
      },
      "contextTokens": 200000,
      "contextPruning": {
        "mode": "cache-ttl",
        "ttl": "55m"
      },
      "compaction": {
        "mode": "safeguard",
        "reserveTokensFloor": 24000,
        "memoryFlush": {
          "enabled": true,
          "softThresholdTokens": 6000,
          "systemPrompt": "Session nearing compaction. Store durable memories now.",
          "prompt": "Write any lasting notes to memory/YYYY-MM-DD.md; reply with NO_REPLY if nothing to store."
        }
      },
      "heartbeat": {
        "every": "55m",
        "target": "last",
        "model": "minimax/MiniMax-M2.5"
      },
      "maxConcurrent": 6,
      "subagents": {
        "model": "minimax/MiniMax-M2.5",
        "maxConcurrent": 12,
        "archiveAfterMinutes": 60
      },
      "memorySearch": {
        "provider": "local",
        "cache": {
          "enabled": true,
          "maxEntries": 50000
        }
      }
    }
  },
  "memory": {
    "backend": "qmd",
    "citations": "auto",
    "qmd": {
      "includeDefaultMemory": true,
      "update": {
        "interval": "5m",
        "debounceMs": 15000
      },
      "limits": {
        "maxResults": 8,
        "timeoutMs": 5000
      },
      "paths": [
        {
          "name": "main-workspace",
          "path": "/home/user/.openclaw/workspace",
          "pattern": "**/*.md"
        },
        {
          "name": "obsidian-kb",
          "path": "/path/to/knowledge-base",
          "pattern": "**/*.md"
        }
      ]
    }
  }
}

这套配置的核心思路：

日常任务用 Sonnet（性价比高），用 /model opus 手动切换到 Opus
启用 Prompt Caching（节约 90% 输入成本）
配置 Context Pruning 自动修剪上下文
配置 Heartbeat 保持缓存温暖
启用 Compaction 和 memoryFlush，避免信息丢失
启用 Memory Search 精准检索
配置 qmd 语义搜索（可选）
子 Agent 使用免费模型，独立上下文避免爆炸
精简 AGENTS.md、SOUL.md、MEMORY.md 文件

总结

回到最开始的公式：