25e - 成本优化

┌─────────────────────────────────────────────────────────────┐
│                  OpenClaw 月度成本构成                        │
├──────────────┬──────────────┬───────────────┬───────────────┤
│  LLM API     │  基础设施     │  外部服务      │   隐性成本     │
│  (70-90%)    │  (5-15%)     │  (5-10%)      │  (常被忽略)    │
│              │              │               │               │
│ • 模型调用    │ • VPS/云主机  │ • 搜索 API    │ • 上下文膨胀   │
│ • Token 消耗  │ • 数据库存储  │ • MCP 工具    │ • 会话历史累积 │
│ • 嵌入生成    │ • Redis 缓存  │ • 邮件/通知   │ • 系统 Prompt  │
│ • 工具调用    │ • 日志存储    │ • 第三方 API  │ • Agent 循环   │
├──────────────┴──────────────┴───────────────┴───────────────┤
│  典型月度总成本：$50-500（个人）/ $500-5,000（团队）           │
└─────────────────────────────────────────────────────────────┘

用户请求 ──→ 路由层 ──┬──→ 简单任务（70-80%）──→ 轻量模型（$0.10-0.40/1M）
                      │     • 状态查询
                      │     • 简单分类
                      │     • 格式转换
                      │     • 日常问答
                      │
                      ├──→ 中等任务（15-20%）──→ 中端模型（$0.40-3.00/1M）
                      │     • 代码生成
                      │     • 文档摘要
                      │     • 数据分析
                      │
                      └──→ 复杂任务（5-10%）──→ 旗舰模型（$3.00-15.00/1M）
                            • 多步推理
                            • 架构决策
                            • 安全审计

# .env — OpenClaw 多模型配置
 
# 方式一：通过 OpenRouter 统一接入（推荐）
OPENROUTER_API_KEY=sk-or-v1-xxxxxxxxxxxx
 
# 方式二：直接配置各提供商 API Key
ANTHROPIC_API_KEY=sk-ant-xxxxxxxxxxxx
OPENAI_API_KEY=sk-xxxxxxxxxxxx
GOOGLE_API_KEY=AIzaxxxxxxxxxxxx
 
# 默认模型（日常任务）
DEFAULT_MODEL=anthropic/claude-sonnet-4
 
# 本地模型（零成本后备）
OLLAMA_BASE_URL=http://localhost:11434

# config/model-routing.yml — 模型路由配置
 
routing:
  # 默认模型（平衡性价比）
  default: "anthropic/claude-haiku-3.5"
  
  # 基于任务类型的路由
  rules:
    # 复杂编码和架构任务 → 旗舰模型
    - match:
        task_type: ["coding", "architecture", "security-audit"]
        complexity: "high"
      model: "anthropic/claude-sonnet-4"
      max_tokens: 8192
    
    # 日常对话和简单查询 → 轻量模型
    - match:
        task_type: ["chat", "lookup", "status-check"]
        complexity: "low"
      model: "openai/gpt-4.1-nano"
      max_tokens: 2048
    
    # 文档摘要和数据分析 → 中端模型
    - match:
        task_type: ["summarize", "analyze", "report"]
        complexity: "medium"
      model: "openai/gpt-4.1-mini"
      max_tokens: 4096
    
    # 本地后备（搜索、草稿、心跳检查）→ 零成本
    - match:
        task_type: ["draft", "search-local", "heartbeat"]
      model: "ollama/llama3.1:8b"
      max_tokens: 2048
 
  # 降级策略
  fallback:
    - model: "openai/gpt-4.1-mini"    # 主模型不可用时
    - model: "ollama/llama3.1:8b"      # 所有云模型不可用时

// OpenRouter 自动路由配置
{
  "model": "openrouter/auto",
  "route": "fallback",
  "models": [
    "anthropic/claude-sonnet-4",
    "openai/gpt-4.1-mini",
    "google/gemini-2.5-flash"
  ],
  "provider": {
    "order": ["Anthropic", "OpenAI", "Google"],
    "allow_fallbacks": true,
    "require_parameters": true
  }
}

# litellm-config.yml — LiteLLM 路由配置
 
model_list:
  # 旗舰模型
  - model_name: "flagship"
    litellm_params:
      model: "claude-sonnet-4-20250514"
      api_key: "sk-ant-xxxxxxxxxxxx"
    model_info:
      max_tokens: 8192
      input_cost_per_token: 0.000003
      output_cost_per_token: 0.000015
 
  # 日常模型
  - model_name: "daily"
    litellm_params:
      model: "gpt-4.1-mini"
      api_key: "sk-xxxxxxxxxxxx"
    model_info:
      max_tokens: 4096
      input_cost_per_token: 0.0000004
      output_cost_per_token: 0.0000016
 
  # 轻量模型
  - model_name: "light"
    litellm_params:
      model: "gpt-4.1-nano"
      api_key: "sk-xxxxxxxxxxxx"
    model_info:
      max_tokens: 2048
      input_cost_per_token: 0.0000001
      output_cost_per_token: 0.0000004
 
  # 本地模型
  - model_name: "local"
    litellm_params:
      model: "ollama/llama3.1:8b"
      api_base: "http://ollama:11434"
 
router_settings:
  routing_strategy: "cost-based"     # 基于成本的路由
  num_retries: 2
  timeout: 30
  allowed_fails: 3
  
  # 成本路由规则
  model_group_alias:
    "simple-tasks": "light"
    "medium-tasks": "daily"
    "complex-tasks": "flagship"
    "free-tasks": "local"
 
# 预算限制
litellm_settings:
  max_budget: 500                    # 月度预算上限 $500
  budget_duration: "1mo"
  
general_settings:
  master_key: "sk-litellm-master-key"
  database_url: "postgresql://litellm:password@postgres:5432/litellm"

# docker-compose.yml — 添加 LiteLLM 网关
services:
  litellm:
    image: ghcr.io/berriai/litellm:main-latest
    container_name: openclaw-litellm
    restart: unless-stopped
    ports:
      - "4000:4000"
    volumes:
      - ./litellm-config.yml:/app/config.yml
    command: ["--config", "/app/config.yml"]
    environment:
      - DATABASE_URL=postgresql://litellm:password@postgres:5432/litellm
    networks:
      - openclaw-net
 
  openclaw-gateway:
    image: openclaw/openclaw:${OPENCLAW_VERSION}
    environment:
      # 将 OpenClaw 指向 LiteLLM 网关
      - OPENAI_API_BASE=http://litellm:4000
      - OPENAI_API_KEY=sk-litellm-master-key

你是一个 AI 运维成本优化专家。我需要为 OpenClaw Agent 集群配置智能模型路由策略。

当前情况：
- Agent 数量：[Agent 数量]
- 日均请求量：[请求量]
- 当前月度 LLM 成本：$[当前成本]
- 主要任务类型分布：[任务类型及占比]
- 当前使用模型：[模型名称]

请帮我：
1. 分析当前成本结构，找出最大的浪费点
2. 设计一个三层模型路由策略（旗舰/日常/轻量），为每层推荐具体模型
3. 估算路由优化后的月度成本（保守/乐观两个场景）
4. 生成完整的 model-routing.yml 配置文件
5. 提供路由效果的监控指标和告警阈值

目标：在不降低 Agent 核心任务质量的前提下，将月度 LLM 成本降低 50% 以上。

用户查询 ──→ 嵌入向量化 ──→ 向量相似度搜索 ──┬──→ 命中（相似度 > 阈值）──→ 返回缓存响应
                                              │     延迟: <50ms
                                              │     成本: ~$0
                                              │
                                              └──→ 未命中 ──→ 调用 LLM API ──→ 存入缓存
                                                    延迟: 1-5s
                                                    成本: 正常 Token 费用

# docker-compose.yml — 添加 Redis 向量缓存
services:
  redis-cache:
    image: redis/redis-stack:latest
    container_name: openclaw-redis-cache
    restart: unless-stopped
    ports:
      - "6379:6379"
    volumes:
      - redis_cache_data:/data
    environment:
      - REDIS_ARGS=--maxmemory 2gb --maxmemory-policy allkeys-lru
    networks:
      - openclaw-net
 
volumes:
  redis_cache_data:

# semantic_cache.py — OpenClaw 语义缓存中间件
# pip install redisvl openai
 
from redisvl.extensions.llmcache import SemanticCache
from redisvl.utils.vectorize import OpenAITextVectorizer
import hashlib
import json
import time
 
class OpenClawSemanticCache:
    """OpenClaw 语义缓存，支持多 Agent 隔离和 TTL 管理"""
    
    def __init__(
        self,
        redis_url: str = "redis://localhost:6379",
        similarity_threshold: float = 0.92,
        ttl: int = 3600,  # 缓存 1 小时
    ):
        self.vectorizer = OpenAITextVectorizer(
            model="text-embedding-3-small"  # 低成本嵌入模型
        )
        self.cache = SemanticCache(
            name="openclaw_llm_cache",
            redis_url=redis_url,
            vectorizer=self.vectorizer,
            distance_threshold=(1 - similarity_threshold),
            ttl=ttl,
        )
        self.stats = {"hits": 0, "misses": 0, "saved_tokens": 0}
    
    def get(self, prompt: str, agent_id: str = "default") -> dict | None:
        """查询缓存，返回缓存的响应或 None"""
        cache_key = f"{agent_id}:{prompt}"
        results = self.cache.check(prompt=cache_key)
        
        if results:
            self.stats["hits"] += 1
            cached = results[0]
            self.stats["saved_tokens"] += cached.get("token_count", 0)
            return {
                "response": cached["response"],
                "cached": True,
                "similarity": cached.get("similarity", 1.0),
                "original_cost": cached.get("cost", 0),
            }
        
        self.stats["misses"] += 1
        return None
    
    def store(
        self,
        prompt: str,
        response: str,
        agent_id: str = "default",
        token_count: int = 0,
        cost: float = 0,
    ):
        """存储 LLM 响应到缓存"""
        cache_key = f"{agent_id}:{prompt}"
        self.cache.store(
            prompt=cache_key,
            response=response,
            metadata={
                "agent_id": agent_id,
                "token_count": token_count,
                "cost": cost,
                "cached_at": time.time(),
            },
        )
    
    def get_stats(self) -> dict:
        """获取缓存统计"""
        total = self.stats["hits"] + self.stats["misses"]
        hit_rate = self.stats["hits"] / total if total > 0 else 0
        return {
            "total_requests": total,
            "cache_hits": self.stats["hits"],
            "cache_misses": self.stats["misses"],
            "hit_rate": f"{hit_rate:.1%}",
            "saved_tokens": self.stats["saved_tokens"],
        }

# gptcache_setup.py — GPTCache 配置
# pip install gptcache
 
from gptcache import cache
from gptcache.adapter import openai
from gptcache.embedding import Onnx
from gptcache.manager import CacheBase, VectorBase, get_data_manager
from gptcache.similarity_evaluation.distance import SearchDistanceEvaluation
 
# 初始化嵌入模型（本地运行，零成本）
onnx = Onnx()
 
# 配置缓存存储
cache_base = CacheBase("sqlite")                    # 元数据存储
vector_base = VectorBase(
    "redis",
    host="localhost",
    port=6379,
    dimension=onnx.dimension,
)
data_manager = get_data_manager(cache_base, vector_base)
 
# 初始化缓存
cache.init(
    embedding_func=onnx.to_embeddings,
    data_manager=data_manager,
    similarity_evaluation=SearchDistanceEvaluation(),
)
cache.set_openai_key()
 
# 使用缓存的 OpenAI 调用
response = openai.ChatCompletion.create(
    model="gpt-4.1-mini",
    messages=[{"role": "user", "content": "OpenClaw 如何配置邮件通知？"}],
)
# 第二次相同语义的查询将直接返回缓存结果

// config/openclaw-settings.json — 上下文压缩配置
{
  "context": {
    "contextTokens": 50000,
    "compaction": "aggressive",
    "maxSessionHistory": 20,
    "compactAfterMessages": 10,
    "preserveSystemPrompt": true,
    "preserveRecentMessages": 5
  },
  "agents": {
    "maxConcurrentAgents": 5,
    "agentTimeout": 300,
    "maxToolCallsPerTurn": 10,
    "maxRetriesPerTask": 3
  }
}

<!-- AGENTS.md — 精简版（优化前：8,000 tokens → 优化后：2,000 tokens） -->
 
# Agent 配置
 
## 角色
你是 DevOps 助手，负责服务器监控和自动化运维。
 
## 核心规则
1. 执行命令前确认影响范围
2. 生产环境操作需要审批
3. 保留操作日志
 
## 可用工具
- filesystem: 文件读写
- github: 代码仓库操作
- slack: 团队通知
 
<!-- 删除冗余的示例、历史记录和重复说明 -->
<!-- 每减少 1,000 tokens = 每月节省 $X（取决于模型和请求量） -->

# budget_manager.py — OpenClaw Token 预算管理器
 
import time
from dataclasses import dataclass, field
from typing import Optional
 
@dataclass
class BudgetConfig:
    """多层预算配置"""
    # 单次请求限制
    max_tokens_per_request: int = 8192
    max_cost_per_request: float = 0.10       # $0.10/次
    
    # Agent 级别限制
    max_tokens_per_agent_hour: int = 100_000
    max_cost_per_agent_day: float = 5.00     # $5/Agent/天
    
    # 全局限制
    max_cost_per_day: float = 50.00          # $50/天
    max_cost_per_month: float = 500.00       # $500/月
    
    # 告警阈值
    alert_threshold: float = 0.80            # 80% 时告警
    hard_limit_action: str = "fallback"      # 超限时降级到本地模型
 
@dataclass
class BudgetTracker:
    """预算追踪器"""
    config: BudgetConfig
    daily_cost: float = 0.0
    monthly_cost: float = 0.0
    agent_costs: dict = field(default_factory=dict)
    last_reset_day: int = 0
    last_reset_month: int = 0
    
    def check_budget(
        self, agent_id: str, estimated_tokens: int, model: str
    ) -> dict:
        """检查是否在预算内，返回路由决策"""
        self._maybe_reset()
        
        estimated_cost = self._estimate_cost(estimated_tokens, model)
        
        # 检查单次请求限制
        if estimated_tokens > self.config.max_tokens_per_request:
            return {
                "allowed": False,
                "reason": "exceeds_per_request_limit",
                "action": "truncate_context",
                "max_tokens": self.config.max_tokens_per_request,
            }
        
        # 检查 Agent 日预算
        agent_daily = self.agent_costs.get(agent_id, 0)
        if agent_daily + estimated_cost > self.config.max_cost_per_agent_day:
            return {
                "allowed": True,
                "reason": "agent_budget_warning",
                "action": "downgrade_model",
                "suggested_model": "ollama/llama3.1:8b",
            }
        
        # 检查全局月预算
        if self.monthly_cost + estimated_cost > self.config.max_cost_per_month:
            if self.config.hard_limit_action == "fallback":
                return {
                    "allowed": True,
                    "reason": "monthly_budget_exceeded",
                    "action": "fallback_to_local",
                    "suggested_model": "ollama/llama3.1:8b",
                }
            return {"allowed": False, "reason": "monthly_budget_hard_limit"}
        
        # 检查告警阈值
        alerts = []
        if self.monthly_cost / self.config.max_cost_per_month > self.config.alert_threshold:
            alerts.append("monthly_budget_80_percent")
        if self.daily_cost / self.config.max_cost_per_day > self.config.alert_threshold:
            alerts.append("daily_budget_80_percent")
        
        return {
            "allowed": True,
            "reason": "within_budget",
            "alerts": alerts,
            "remaining_daily": self.config.max_cost_per_day - self.daily_cost,
            "remaining_monthly": self.config.max_cost_per_month - self.monthly_cost,
        }
    
    def record_usage(self, agent_id: str, tokens: int, cost: float):
        """记录实际使用量"""
        self.daily_cost += cost
        self.monthly_cost += cost
        self.agent_costs[agent_id] = self.agent_costs.get(agent_id, 0) + cost
    
    def _estimate_cost(self, tokens: int, model: str) -> float:
        """估算成本（简化版）"""
        cost_per_1m = {
            "claude-sonnet-4": 3.0,
            "claude-haiku-3.5": 0.8,
            "gpt-4.1-mini": 0.4,
            "gpt-4.1-nano": 0.1,
            "gemini-2.5-flash": 0.15,
        }
        rate = cost_per_1m.get(model, 1.0)
        return (tokens / 1_000_000) * rate
    
    def _maybe_reset(self):
        """按日/月重置计数器"""
        now = time.localtime()
        if now.tm_mday != self.last_reset_day:
            self.daily_cost = 0.0
            self.agent_costs = {}
            self.last_reset_day = now.tm_mday
        if now.tm_mon != self.last_reset_month:
            self.monthly_cost = 0.0
            self.last_reset_month = now.tm_mon

# prometheus/rules/cost-alerts.yml — 成本告警规则
 
groups:
  - name: openclaw_cost_alerts
    rules:
      # 日成本超过 80% 预算
      - alert: DailyCostBudgetWarning
        expr: |
          sum(increase(openclaw_llm_cost_total[24h])) > 40
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "OpenClaw 日成本接近预算上限"
          description: |
            过去 24 小时 LLM 成本已达 ${{ $value | printf "%.2f" }}，
            超过日预算 $50 的 80%。
            建议检查是否有 Agent 循环或异常高频调用。
 
      # 月成本超过 80% 预算
      - alert: MonthlyCostBudgetWarning
        expr: |
          sum(increase(openclaw_llm_cost_total[30d])) > 400
        for: 10m
        labels:
          severity: warning
        annotations:
          summary: "OpenClaw 月成本接近预算上限"
          description: |
            本月 LLM 成本已达 ${{ $value | printf "%.2f" }}，
            超过月预算 $500 的 80%。
 
      # 单个 Agent 成本异常（可能存在循环）
      - alert: AgentCostAnomaly
        expr: |
          rate(openclaw_llm_cost_total{agent_id!=""}[1h]) > 2
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "Agent {{ $labels.agent_id }} 成本异常"
          description: |
            Agent {{ $labels.agent_id }} 过去 1 小时成本速率为
            ${{ $value | printf "%.2f" }}/小时，可能存在循环调用。
            建议立即检查并暂停该 Agent。
 
      # Token 消耗速率异常
      - alert: TokenConsumptionSpike
        expr: |
          rate(openclaw_tokens_total[5m]) > 
          2 * avg_over_time(rate(openclaw_tokens_total[5m])[1h:5m])
        for: 10m
        labels:
          severity: warning
        annotations:
          summary: "Token 消耗速率异常飙升"
          description: "当前 Token 消耗速率是过去 1 小时平均值的 2 倍以上。"

# 定期重置会话，防止上下文膨胀
# 建议在 crontab 中配置
 
# 每 2 小时压缩一次活跃会话
0 */2 * * * docker exec openclaw-gateway \
    curl -sf -X POST http://localhost:3000/admin/compact-sessions
 
# 每天清理超过 24 小时的非活跃会话
0 3 * * * docker exec openclaw-gateway \
    curl -sf -X POST http://localhost:3000/admin/cleanup-sessions?older_than=24h
 
# 手动重置特定 Agent 的会话
# openclaw "reset session"
# 或删除会话文件
# rm ~/.openclaw/agents.main/sessions/*.jsonl

月度 LLM 成本 = Σ (每种模型的日均请求数 × 平均 Token/请求 × Token 单价 × 30)

其中：
  平均 Token/请求 = 系统 Prompt Token + 上下文 Token + 输入 Token + 输出 Token
  Token 单价 = (输入价格 × 输入占比 + 输出价格 × 输出占比) / 1,000,000

┌─────────────────────────────────────────────────────────────────────────────┐
│                    OpenClaw 月度成本预测模板                                  │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ===== A. 基础参数 =====                                                    │
│                                                                             │
│  Agent 数量:              [5]                                               │
│  日均请求数/Agent:         [200]                                             │
│  平均输入 Token/请求:      [3,000]  (含系统 Prompt + 上下文)                  │
│  平均输出 Token/请求:      [800]                                             │
│  工作日数/月:              [30]                                              │
│                                                                             │
│  ===== B. 模型路由分配 =====                                                 │
│                                                                             │
│  模型层级    │ 流量占比 │ 模型名称          │ 输入$/1M │ 输出$/1M             │
│  ──────────┼────────┼─────────────────┼────────┼────────                  │
│  旗舰       │  10%   │ Claude Sonnet 4  │ $3.00  │ $15.00                  │
│  日常       │  30%   │ GPT-4.1 mini     │ $0.40  │ $1.60                   │
│  轻量       │  40%   │ GPT-4.1 nano     │ $0.10  │ $0.40                   │
│  本地       │  20%   │ Ollama Llama3.1  │ $0.00  │ $0.00                   │
│                                                                             │
│  ===== C. 月度成本计算 =====                                                 │
│                                                                             │
│  总请求数/月 = 5 × 200 × 30 = 30,000                                       │
│                                                                             │
│  旗舰层:                                                                    │
│    请求数 = 30,000 × 10% = 3,000                                           │
│    输入成本 = 3,000 × 3,000 / 1M × $3.00 = $27.00                         │
│    输出成本 = 3,000 × 800 / 1M × $15.00 = $36.00                          │
│    小计 = $63.00                                                            │
│                                                                             │
│  日常层:                                                                    │
│    请求数 = 30,000 × 30% = 9,000                                           │
│    输入成本 = 9,000 × 3,000 / 1M × $0.40 = $10.80                         │
│    输出成本 = 9,000 × 800 / 1M × $1.60 = $11.52                           │
│    小计 = $22.32                                                            │
│                                                                             │
│  轻量层:                                                                    │
│    请求数 = 30,000 × 40% = 12,000                                          │
│    输入成本 = 12,000 × 3,000 / 1M × $0.10 = $3.60                         │
│    输出成本 = 12,000 × 800 / 1M × $0.40 = $3.84                           │
│    小计 = $7.44                                                             │
│                                                                             │
│  本地层:                                                                    │
│    请求数 = 30,000 × 20% = 6,000                                           │
│    成本 = $0.00（仅电费）                                                    │
│                                                                             │
│  ===== D. 缓存节省 =====                                                    │
│                                                                             │
│  预估缓存命中率:  30%                                                       │
│  缓存节省金额 = ($63.00 + $22.32 + $7.44) × 30% = $27.83                  │
│                                                                             │
│  ===== E. 嵌入成本 =====                                                    │
│                                                                             │
│  嵌入请求数/月:   10,000                                                    │
│  平均 Token/请求:  500                                                      │
│  嵌入模型:        text-embedding-3-small ($0.02/1M)                         │
│  嵌入成本 = 10,000 × 500 / 1M × $0.02 = $0.10                             │
│                                                                             │
│  ===== F. 总计 =====                                                        │
│                                                                             │
│  LLM API 成本:     $92.76                                                   │
│  缓存节省:         -$27.83                                                  │
│  嵌入成本:         $0.10                                                    │
│  ─────────────────────────                                                  │
│  优化后月度成本:    $65.03                                                   │
│                                                                             │
│  对比：全部使用 Claude Sonnet 4 的成本                                       │
│  = 30,000 × (3,000/1M × $3.00 + 800/1M × $15.00) = $630.00               │
│                                                                             │
│  ✅ 节省率: 89.7%                                                           │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

你是一个 AI 运营成本分析师。请根据以下 OpenClaw 部署参数，生成一份详细的月度成本预测报告。

部署参数：
- Agent 数量：[Agent 数量]
- 每个 Agent 的日均请求数：[请求数]
- 主要任务类型：[任务类型列表]
- 当前使用模型：[模型名称]
- 是否已配置模型路由：[是/否]
- 是否已配置语义缓存：[是/否]
- 月度预算上限：$[预算]

请生成：
1. 当前配置下的月度成本估算（明细到每个模型）
2. 优化后的月度成本估算（应用模型路由 + 缓存）
3. 三种预算方案对比（保守/平衡/激进）
4. 成本趋势预测（未来 3 个月，考虑业务增长）
5. 具体的优化行动清单（按投入产出比排序）

输出格式：Markdown 表格 + 关键数字高亮

正常 Agent 执行:
  用户请求 → 思考 → 工具调用 → 结果 → 响应    (5-10K tokens)

Agent 循环（成本炸弹）:
  用户请求 → 思考 → 工具调用 → 失败 → 重试 → 失败 → 换工具 →
  失败 → 请求帮助 → 子 Agent → 子 Agent 也失败 → 回到主 Agent →
  重新开始 → ...                                (100K-500K+ tokens)

# config/agent-guardrails.yml — Agent 循环防护
 
guardrails:
  # 单次任务的最大工具调用次数
  max_tool_calls_per_task: 15
  
  # 单次任务的最大 Token 消耗
  max_tokens_per_task: 50000
  
  # 连续失败次数上限（超过则暂停并通知）
  max_consecutive_failures: 3
  
  # Agent 间委托深度限制
  max_delegation_depth: 3
  
  # 单个 Agent 的最大运行时间（秒）
  max_agent_runtime: 600
  
  # 重复工具调用检测
  duplicate_detection:
    enabled: true
    window: 10                    # 检查最近 10 次调用
    threshold: 3                  # 同一工具+参数出现 3 次则告警
  
  # 超限行为
  on_limit_exceeded:
    action: "pause_and_notify"    # 暂停 Agent 并通知管理员
    notification_channel: "slack"
    fallback_response: "任务复杂度超出预期，已暂停执行。请检查任务描述或手动介入。"

# 每个 Agent 的小时 Token 消耗
sum by (agent_id) (
  increase(openclaw_tokens_total[1h])
)

# 工具调用失败率（检测潜在循环）
sum by (agent_id) (
  rate(openclaw_tool_calls_failed_total[5m])
) / sum by (agent_id) (
  rate(openclaw_tool_calls_total[5m])
)

# 成本 Top 10 Agent
topk(10,
  sum by (agent_id) (
    increase(openclaw_llm_cost_total[24h])
  )
)

# config/tool-optimization.yml — 工具调用优化
 
tools:
  # 文件系统工具：限制返回大小
  filesystem:
    max_file_size: 10240           # 最大读取 10KB
    max_files_per_call: 5
    truncate_large_files: true
  
  # Web 搜索：优先使用免费替代
  web_search:
    primary: "exa"                 # Exa AI（免费）
    fallback: "tavily"             # Tavily（付费后备）
    max_results: 3
    cache_ttl: 3600
  
  # 数据库：限制查询结果
  database:
    max_rows: 50
    timeout: 10
    read_only: true                # 默认只读
  
  # 通用设置
  global:
    max_tool_result_tokens: 2000   # 工具结果最大 Token 数
    truncate_strategy: "smart"     # 智能截断（保留关键信息）
    cache_tool_results: true       # 缓存工具结果
    cache_ttl: 300                 # 5 分钟缓存

# 使用 openclaw 命令查看月度用量
openclaw usage --this-month
 
# 输出示例：
# Total tokens:     12,500,000
# Total cost:       $1,247.50
# Top agents by cost:
#   1. code-review-agent:    $420.00 (33.7%)
#   2. content-agent:        $280.00 (22.4%)
#   3. email-agent:          $180.00 (14.4%)
#   4. devops-agent:         $150.00 (12.0%)
#   5. customer-service:     $120.00  (9.6%)
#   6. data-analysis:         $52.00  (4.2%)
#   7. monitoring-agent:      $30.00  (2.4%)
#   8. daily-report:          $15.50  (1.2%)

# ===== 第 1 步：模型路由（节省 60%）=====
 
# 分析各 Agent 任务复杂度，配置差异化模型
# config/model-routing.yml
 
# code-review-agent → 保持 Claude Sonnet 4（需要高质量代码分析）
# content-agent → 降级到 GPT-4.1 mini（内容生成质量足够）
# email-agent → 降级到 GPT-4.1 nano（邮件分类和简单回复）
# devops-agent → 降级到 GPT-4.1 mini（日常运维命令）
# customer-service → 降级到 Claude Haiku 3.5（快速响应）
# data-analysis → 保持 Claude Sonnet 4（需要准确分析）
# monitoring-agent → 降级到 Ollama 本地模型（状态检查零成本）
# daily-report → 降级到 GPT-4.1 nano（模板化报告）
 
# 预估节省：$1,200 → $480（-60%）
 
# ===== 第 2 步：语义缓存（再节省 25%）=====
 
# 部署 Redis 语义缓存
docker compose up -d redis-cache
 
# 配置缓存规则
# - 客服常见问答：缓存 24 小时，命中率预估 40%
# - 邮件分类结果：缓存 1 小时，命中率预估 30%
# - 监控状态查询：缓存 5 分钟，命中率预估 50%
 
# 预估节省：$480 → $360（-25%）
 
# ===== 第 3 步：上下文压缩（再节省 30%）=====
 
# 精简所有 Agent 的 AGENTS.md
# 配置激进压缩
# 设置会话自动重置
 
# config/openclaw-settings.json
# "contextTokens": 50000
# "compaction": "aggressive"
# "maxSessionHistory": 15
 
# 预估节省：$360 → $250（-30%）
 
# ===== 第 4 步：工具调用优化（再节省 28%）=====
 
# 替换付费 Web 搜索为 Exa AI（免费）
# 限制工具返回数据大小
# 启用工具结果缓存
 
# 预估节省：$250 → $180（-28%）