token-optimization

令牌优化

Agent Skills™ 的一部分，由 googleadsagent.ai™ 提供

描述

令牌优化是指在不牺牲输出质量的前提下，系统性地减少 Agent 操作中的令牌消耗。在生产级 AI 系统中，令牌是成本和延迟的基本计量单位：每个不必要的令牌都会增加 API 账单并拖慢响应速度。这项技能总结了 Everything Claude Code 生态系统（超过 150k 颗星）和 googleadsagent.ai™ 生产平台所采用的优化技术。在该平台上，Buddy™ 每天处理数千次 Google Ads 分析，同时严格控制成本。

优化涉及四个维度：模型选择（根据任务复杂度匹配模型能力与成本）、提示词压缩（在保留指令完整性的同时去除冗余令牌）、后台处理（将高成本操作转交给异步工作流），以及缓存（避免对相同或相似输入进行重复计算）。实现全部四个维度的生产系统，相比简单实现通常可将令牌成本降低 60-80%。

令牌优化并非一味省钱，而是提升效率。Agent 若将令牌浪费在冗长的系统提示词或重复的工具输出上，不仅成本高，还会更快填满上下文窗口，留给实际推理的空间也更少。优化能同时提升经济效益和质量。

使用场景

• AI Agent 操作的月度 API 成本超出预算目标
• 面向用户的 Agent 响应延迟超过可接受的阈值
• 复杂任务尚未完成，上下文窗口就已被填满
• 可用多个模型层级，需要智能路由
• 批处理工作负载产生大量令牌
• 需要扩展 Agent 使用规模，但不希望成本同比例增长

工作原理

graph TD
    A[Incoming Task] --> B[Complexity Classifier]
    B -->|Simple| C[Fast Model<br/>Haiku/Flash]
    B -->|Medium| D[Balanced Model<br/>Sonnet/GPT-4o]
    B -->|Complex| E[Premium Model<br/>Opus/o1]
    C --> F[Prompt Compressor]
    D --> F
    E --> F
    F --> G{Cache Hit?}
    G -->|Yes| H[Return Cached Result]
    G -->|No| I[Execute with Budget]
    I --> J[Cache Result]
    J --> K[Response]
    H --> K
    I --> L{Background Eligible?}
    L -->|Yes| M[Async Queue]
    M --> I
    L -->|No| I

任务首先经过复杂度分类器，再被路由到合适的模型层级。提示词压缩器会剔除冗余内容、缩短冗长指令，并以结构化格式替代叙述性描述。缓存层会拦截重复或近似重复的查询。适合后台处理的任务（非交互式分析、批处理操作）会被加入队列，在高峰时段之外进行异步处理。每个阶段都会执行令牌预算，以硬性限制每次操作的支出。

实现

任务复杂度分类器：

class ComplexityClassifier:
    THRESHOLDS = {
        "simple": {"max_tokens": 500, "patterns": ["summarize", "format", "list", "count"]},
        "medium": {"max_tokens": 2000, "patterns": ["analyze", "compare", "explain", "review"]},
        "complex": {"max_tokens": 8000, "patterns": ["architect", "refactor", "debug", "optimize"]},
    }

    def classify(self, task: str) -> str:
        task_lower = task.lower()
        scores = {}
        for level, config in self.THRESHOLDS.items():
            score = sum(1 for p in config["patterns"] if p in task_lower)
            scores[level] = score

        if scores["complex"] > 0:
            return "complex"
        if scores["medium"] > 0:
            return "medium"
        return "simple"

    def select_model(self, complexity: str) -> dict:
        models = {
            "simple": {"name": "claude-haiku", "cost_per_1k": 0.00025, "max_tokens": 1024},
            "medium": {"name": "claude-sonnet", "cost_per_1k": 0.003, "max_tokens": 4096},
            "complex": {"name": "claude-opus", "cost_per_1k": 0.015, "max_tokens": 8192},
        }
        return models[complexity]

提示词压缩引擎：

class PromptCompressor:
    REPLACEMENTS = [
        (r"\s+", " "),
        (r"Please note that ", ""),
        (r"It is important to ", ""),
        (r"Make sure to ", ""),
        (r"You should ", ""),
        (r"In order to ", "To "),
        (r"At this point in time", "Now"),
    ]

    def compress(self, prompt: str, target_reduction: float = 0.3) -> str:
        compressed = prompt
        for pattern, replacement in self.REPLACEMENTS:
            compressed = re.sub(pattern, replacement, compressed)

        original_tokens = count_tokens(prompt)
        compressed_tokens = count_tokens(compressed)
        reduction = 1 - (compressed_tokens / original_tokens)

        if reduction < target_reduction:
            compressed = self.structural_compress(compressed, target_reduction)

        return compressed.strip()

    def structural_compress(self, text: str, target: float) -> str:
        lines = text.split("\n")
        scored = [(line, self.line_importance(line)) for line in lines]
        scored.sort(key=lambda x: x[1], reverse=True)

        result = []
        tokens = 0
        budget = int(count_tokens(text) * (1 - target))
        for line, score in scored:
            line_tokens = count_tokens(line)
            if tokens + line_tokens <= budget:
                result.append(line)
                tokens += line_tokens
        return "\n".join(result)

    def line_importance(self, line: str) -> float:
        if line.strip().startswith("#"):
            return 1.0
        if any(kw in line.lower() for kw in ["must", "required", "never", "always"]):
            return 0.9
        if line.strip().startswith("-") or line.strip().startswith("*"):
            return 0.7
        return 0.5

语义缓存层：

import { createHash } from "crypto";

interface CacheEntry {
  result: string;
  timestamp: number;
  tokens_saved: number;
  model: string;
}

class SemanticCache {
  private cache: Map<string, CacheEntry> = new Map();
  private ttlMs: number;
  private totalSaved = 0;

  constructor(ttlMinutes = 60) {
    this.ttlMs = ttlMinutes * 60 * 1000;
  }

  private keyFor(prompt: string, model: string): string {
    const normalized = prompt.toLowerCase().replace(/\s+/g, " ").trim();
    return createHash("sha256").update(`${model}:${normalized}`).digest("hex").slice(0, 32);
  }

  get(prompt: string, model: string): CacheEntry | null {
    const key = this.keyFor(prompt, model);
    const entry = this.cache.get(key);
    if (!entry) return null;
    if (Date.now() - entry.timestamp > this.ttlMs) {
      this.cache.delete(key);
      return null;
    }
    this.totalSaved += entry.tokens_saved;
    return entry;
  }

  set(prompt: string, model: string, result: string, tokensUsed: number): void {
    const key = this.keyFor(prompt, model);
    this.cache.set(key, {
      result,
      timestamp: Date.now(),
      tokens_saved: tokensUsed,
      model,
    });
  }

  stats(): { entries: number; totalTokensSaved: number } {
    return { entries: this.cache.size, totalTokensSaved: this.totalSaved };
  }
}

最佳实践

1. 先测量，再优化 —— 按操作类型（系统提示词、用户消息、工具结果、生成内容）监测令牌用量，以确定影响最大的优化目标。
2. 选择合适规模的模型 —— 简单任务（格式整理、摘要）使用快速、低成本的模型，复杂推理才使用高成本模型；大多数任务不需要能力最强的模型。
3. 大幅压缩系统提示词 —— 系统提示词会随每次请求发送；将其压缩 30%，就能让每次调用都受益。
4. 在语义层面缓存 —— 精确匹配缓存可捕获重复项；语义相似度缓存则可捕获会产生相同结果的近似重复项。
5. 为每种操作设置令牌预算 —— 硬性限制可防止模型输出意外冗长或工具调用循环导致成本失控。
6. 优先使用结构化格式，而非散文 —— JSON 和 YAML 每个令牌承载的信息量高于自然语言描述。
7. 智能截断工具输出 —— 仅返回模型需要的字段，而不是完整的 API 响应；通过选择性提取字段，可将 Google Ads API 响应从 50k 令牌缩减到 2k 令牌。
8. 监控每个成功任务的成本 —— 不要只追踪原始令牌用量，还要追踪每个已完成任务的令牌数，以反映重试和失败的影响。

平台兼容性

功能	Claude Code	Cursor	Codex	Gemini CLI
模型路由	✅ --model flag	✅ 模型选择器	✅ 模型配置	✅ 模型标志
提示词压缩	✅ 完整	✅ 完整	✅ 完整	✅ 完整
响应缓存	✅ 自定义	✅ 自定义	✅ 自定义	✅ 上下文缓存
后台任务	✅ 子 Agent	✅ 子 Agent	✅ 异步	✅ 异步
令牌预算	✅ max_tokens	✅ max_tokens	✅ max_tokens	✅ max_tokens

相关技能

• 多模型路由 - 模型路由是降低令牌成本最有效的技术
• 知识库注入 - Top-K 模式选择可避免过度注入导致上下文窗口膨胀
• 记忆持久化 - 记忆注入预算必须与当前任务的上下文需求相平衡
• 预算优化 - 将类似的成本效益优化原则应用于广告支出分配

关键词

令牌优化、成本降低、模型路由、提示词压缩、缓存、批处理、令牌预算、模型选择、延迟优化、Agent 技能

---

© 2026 googleadsagent.ai™ | Agent Skills™ | MIT License