Agent Token 优化完全指南：在保证效果的前提下降低成本提升性能

2026-04-15

前言

在 Agent 开发中，Token 消耗直接关系到成本和性能。如何在保证效果的前提下，减少 Token 使用，是每个 Agent 架构师都需要面对的核心问题。

本文系统化梳理了 7 大优化策略、30+ 具体技术，并提供完整的实施路线图，帮助你将成本降低 30-70%，同时保持 85% 以上的质量。

一、Token 成本分析

1.1 Token 消耗构成

1	总 Token 成本 = 输入 Token + 输出 Token + 工具调用 Token + 缓存 Token

典型 Agent 调用分解：

系统提示词：~500-2000 tokens
历史上下文：~1000-5000 tokens
任务指令：~200-1000 tokens
工具描述：~1000-3000 tokens
知识库检索：~500-2000 tokens
输出内容：~500-3000 tokens

1.2 成本计算示例

假设使用 GPT-4.1（$5/1M input, $15/1M output）：

场景	输入 Tokens	输出 Tokens	单次成本	日均调用	月成本
简单问答	500	300	$0.007	1000	$210
复杂推理	3000	1500	$0.0375	100	$112.5
多轮对话	5000	2000	$0.055	50	$82.5
长文档分析	8000	3000	$0.085	20	$51

优化空间： 30%-70% 的 token 可以通过合理设计节省

二、核心优化策略

策略 1: 提示词优化

2.1.1 精简系统提示词

❌ 冗余示例：

你是一个专业的 AI 助手，需要帮助用户完成各种任务。你应该：
1. 理解用户的需求和意图
2. 分析问题的核心和关键点
3. 提供准确、全面、有价值的回答
4. 如果不确定，要诚实地说明
5. 保持友好、专业的态度
6. 遵循道德和法律规范
7. 保护用户隐私
...
（共 800+ tokens）

✅ 优化示例：

1 2	专业助手。简洁、准确、诚实、守法。（仅 8 tokens，节省 99%）

2.1.2 使用少样本学习代替详细指令

❌ 指令式：

当用户询问天气时，你应该：
1. 确认用户的位置
2. 询问具体日期和时间
3. 查询天气信息
4. 以友好的方式呈现结果
5. 包含温度、湿度、风向等信息
...
（300+ tokens）

✅ 示例式：

Q: 北京今天天气怎么样？
A: 北京今天：晴，气温 25°C，湿度 45%，风向：东北风3级

Q: 上海明天会下雨吗？
A: 上海明天：小雨，气温 22°C，降水概率 70%，建议携带雨具
（50 tokens，节省 83%）

2.1.3 结构化提示词

interface SystemPrompt {
  role: string;        // "专业助手" (简洁)
  rules: string[];     // ["简洁", "准确", "诚实"]
  tools: string[];     // 只包含实际使用的工具
  context: Context;    // 只包含必要上下文
}

// 压缩格式
const prompt = compact({
  role: '分析师',
  rules: ['数据驱动', '结论优先'],
  output: 'JSON格式'
});

策略 2: 上下文管理

2.2.1 智能上下文裁剪

// 上下文压缩算法
function compressHistory(messages: Message[], maxTokens: number): Message[] {
  const priority = {
    user: 3,        // 用户消息优先级最高
    assistant: 2,   // 助手回复中等
    system: 1       // 系统消息最低
  };

  // 1. 保留最近 N 条消息
  const recent = messages.slice(-10);

  // 2. 基于重要性评分
  const scored = messages.map(msg => ({
    ...msg,
    score: calculateImportance(msg, priority)
  }));

  // 3. 按评分排序，选择 top-K
  const selected = scored
    .sort((a, b) => b.score - a.score)
    .slice(0, maxTokens);

  // 4. 去除冗余（相似的消息）
  return deduplicate(selected);
}

function calculateImportance(msg: Message, priority: any): number {
  let score = priority[msg.role] || 0;

  // 包含关键信息
  if (hasKeywords(msg, ['error', 'issue', 'important'])) score += 2;

  // 用户反馈
  if (msg.role === 'user') score += 1;

  // 时间衰减（越新的越重要）
  const age = Date.now() - msg.timestamp;
  score *= Math.exp(-age / (24 * 60 * 60 * 1000)); // 24小时衰减

  return score;
}

2.2.2 分层记忆系统

interface MemoryLayers {
  working: Message[];     // 最近 10 条对话，直接提供给 LLM
  episodic: Summary[];    // 最近 100 条对话的摘要
  semantic: VectorDB;     // 长期记忆，语义检索
}

async function getContext(query: string, layers: MemoryLayers) {
  // 1. 工作记忆（直接使用）
  const workingContext = layers.working;

  // 2. 情景记忆（检索相关摘要）
  const episodicQuery = embed(query);
  const relevantEpisodes = await layers.semantic.search(
    episodicQuery,
    topK=3
  );

  // 3. 语义记忆（检索相关知识）
  const semanticMatches = await layers.semantic.search(
    query,
    topK=5
  );

  // 4. 智能压缩
  return compressContext({
    working: workingContext,
    episodes: relevantEpisodes.map(e => e.summary),
    knowledge: semanticMatches.map(k => k.content)
  });
}

// 压缩后 token 使用：从 5000+ → 1000-1500

2.2.3 对话摘要技术

// 自动摘要生成
async function summarizeConversation(messages: Message[]): Promise<string> {
  const summaryPrompt = `
请用 100 字以内总结这段对话的核心内容：

${messages.map(m => `${m.role}: ${m.content}`).join('\n')}
  `.trim();

  // 使用更便宜的模型做摘要
  const summary = await llm.call(summaryPrompt, {
    model: 'gpt-3.5-turbo',  // 比 GPT-4 便宜 10 倍
    maxTokens: 100
  });

  return summary;
}

// 应用：每 10 轮对话生成一次摘要，替换原始对话
// Token 节省：从 5000 tokens → 200 tokens

策略 3: 工具调用优化

2.3.1 精简工具描述

❌ 冗余描述：

const tools = [{
  name: 'search_web',
  description: `这是一个强大的网络搜索工具，可以帮助你在互联网上查找各种信息。
    你可以使用它来搜索新闻、文档、教程、学术论文等多种类型的内容。
    支持的关键词搜索可以精确匹配你提供的内容，也可以进行模糊搜索。
    搜索结果会包含标题、摘要和链接，你可以根据需要选择性地使用。`,
  parameters: { ... }
}];

// 工具描述 token：300+

✅ 精简描述：

const tools = [{
  name: 'search_web',
  description: '搜索网页，返回标题、摘要、链接',
  parameters: {
    type: 'object',
    properties: {
      query: {
        type: 'string',
        description: '搜索关键词'
      },
      limit: {
        type: 'number',
        description: '结果数量 (1-10)',
        default: 5
      }
    },
    required: ['query']
  }
}];

// 工具描述 token：50 (节省 83%)

2.3.2 工具合并与复用

// ❌ 分散的工具
const tools = [
  { name: 'get_user', description: '获取用户信息' },
  { name: 'update_user', description: '更新用户信息' },
  { name: 'delete_user', description: '删除用户' },
  { name: 'create_user', description: '创建用户' },
  { name: 'list_users', description: '列出用户' }
];

// 总 token：500+

// ✅ 统一的 CRUD 工具
const tools = [{
  name: 'user_crud',
  description: '用户管理：创建、查询、更新、删除',
  parameters: {
    operation: { type: 'enum', values: ['create', 'read', 'update', 'delete', 'list'] },
    data: { type: 'object' }  // 根据操作类型提供不同字段
  }
}];

// 总 token：100 (节省 80%)

2.3.3 智能工具选择

class SmartToolManager {
  private toolStats = new Map<string, ToolStats>();

  async selectTools(query: string): Promise<Tool[]> {
    // 1. 分析用户意图
    const intent = await this.analyzeIntent(query);

    // 2. 基于历史使用统计选择最可能的工具
    const likelyTools = this.getMostUsedTools(intent);

    // 3. 只提供相关工具，避免干扰
    return likelyTools.filter(tool =>
      this.isRelevant(tool, query)
    ).slice(0, 3);  // 最多 3 个工具
  }

  private getMostUsedTools(intent: string): Tool[] {
    return Array.from(this.toolStats.entries())
      .sort((a, b) => b[1].successRate - a[1].successRate)
      .slice(0, 5)
      .map(([name]) => this.tools.get(name));
  }
}

// 效果：工具描述从 2000 tokens → 500 tokens

策略 4: 知识库优化

2.4.1 向量化检索 + Rerank

// ❌ 直接将所有知识放入上下文
const prompt = `
知识库：
${fullKnowledgeBase}  // 10,000+ tokens

用户问题：${query}
`;

// ✅ 检索 + 精排
async function getRelevantKnowledge(query: string, topK: number = 5) {
  // 1. 粗排：向量检索（快速）
  const candidates = await vectorDB.search(query, topK=20);

  // 2. 精排：使用小模型重新评分
  const reranked = await rerank(query, candidates);

  // 3. 选择 top-K
  return reranked.slice(0, topK);
}

// Prompt 示例
const prompt = `
相关知识：
${relevantKnowledge.join('\n\n')}  // 1000 tokens

用户问题：${query}
`;

// Token 节省：10,000 → 1,000 (90%)

2.4.2 分块优化

// 智能分块策略
async function smartChunk(text: string): Promise<Chunk[]> {
  // 1. 按语义分块（而不是固定长度）
  const semanticChunks = await splitBySemantic(text);

  // 2. 每个块添加摘要（用于检索）
  const chunks = await Promise.all(
    semanticChunks.map(async (chunk) => ({
      content: chunk,
      summary: await summarize(chunk),
      embedding: await embed(chunk),
      metadata: {
        tokens: countTokens(chunk),
        keywords: extractKeywords(chunk)
      }
    }))
  );

  return chunks;
}

// 使用时只提供摘要，按需展开完整内容

2.4.3 知识图谱

// 结构化知识存储
interface KnowledgeGraph {
  entities: Map<string, Entity>;
  relations: Relation[];
}

async function queryGraph(query: string): Promise<string> {
  // 1. 实体识别
  const entities = await extractEntities(query);

  // 2. 图遍历（高效，不需要 LLM）
  const paths = graph.findPaths(entities, depth=2);

  // 3. 路径压缩为文本
  return paths.map(path => path.toText()).join('\n');
}

// Token 节省：相比全文检索，节省 60-80%

策略 5: 模型选择与混合

2.5.1 分层模型架构

interface ModelLayer {
  model: string;
  cost: number;        // cost per 1M tokens
  capability: number;  // 0-1
  useCases: string[];
}

const layers: ModelLayer[] = [
  {
    model: 'gpt-4.1',
    cost: 10,
    capability: 1.0,
    useCases: ['复杂推理', '代码生成', '系统设计']
  },
  {
    model: 'gpt-4o-mini',
    cost: 0.15,
    capability: 0.8,
    useCases: ['文本摘要', '简单问答', '分类']
  },
  {
    model: 'claude-3-haiku',
    cost: 0.25,
    capability: 0.75,
    useCases: ['快速响应', '多轮对话']
  }
];

async function selectModel(task: Task): Promise<string> {
  // 1. 分析任务复杂度
  const complexity = estimateComplexity(task);

  // 2. 预算限制
  const budget = getBudget(task.user);

  // 3. 选择合适的模型
  const suitable = layers.filter(l =>
    l.capability >= complexity &&
    l.cost <= budget
  );

  return suitable[0]?.model || 'gpt-4o-mini';
}

// 效果：平均成本降低 40-60%

2.5.2 小模型预处理 + 大模型后处理

async function optimizedPipeline(input: string) {
  // 1. 小模型预处理（分类、提取）
  const intent = await smallModel.classify(input);
  const entities = await smallModel.extract(input);

  // 2. 检索相关知识
  const knowledge = await retrieve(intent, entities);

  // 3. 大模型处理（生成高质量答案）
  const response = await largeModel.generate({
    context: knowledge,
    entities,
    intent
  });

  return response;
}

// 成本：$0.001 (预处理) + $0.005 (后处理) = $0.006
// vs 直接大模型：$0.02
// 节省：70%

2.5.3 缓存与重用

class ResponseCache {
  private cache = new Map<string, CachedResponse>();

  async get(key: string): Promise<string | null> {
    const cached = this.cache.get(key);
    if (!cached) return null;

    // 缓存失效策略
    if (Date.now() - cached.timestamp > 3600000) { // 1小时
      this.cache.delete(key);
      return null;
    }

    return cached.response;
  }

  async set(key: string, response: string): Promise<void> {
    this.cache.set(key, {
      response,
      timestamp: Date.now()
    });
  }
}

// 应用：常见问题的缓存命中率可达 40-60%
// Token 节省：40-60%

策略 6: 输出优化

2.6.1 结构化输出

// ❌ 自由文本输出
const prompt = '请分析这段代码的问题...';
// 输出：可能冗长，500+ tokens

// ✅ 结构化输出（JSON）
const prompt = `
分析代码，返回 JSON 格式：
{
  "issues": [
    {
      "type": "security|performance|bug",
      "severity": "critical|high|medium|low",
      "line": number,
      "description": "简短描述 (20字内)"
    }
  ],
  "suggestions": ["修复建议1", "修复建议2"]
}
`;
// 输出：简洁，100-200 tokens (节省 60-80%)

2.6.2 输出长度限制

// 智能截断
async function generateWithLimit(prompt: string, maxTokens: number) {
  // 1. 设置 maxTokens
  const response = await llm.generate(prompt, {
    maxTokens: Math.min(maxTokens, 500)  // 限制最大输出
  });

  // 2. 后处理：确保完整性
  return ensureComplete(response);
}

// 配合 stop token
const response = await llm.generate(prompt, {
  stop: ['\n\n---', '---\n'],  // 在特定标记处停止
  maxTokens: 300
});

2.6.3 迭代式生成

// ❌ 一次性生成长内容
const prompt = '生成一份完整的用户手册...';
// 输出：2000+ tokens

// ✅ 迭代式生成
async function generateIteratively(topic: string) {
  const sections = await llm.generate(`
    列出 "${topic}" 手册的主要章节（最多5个）
  `);

  const content = [];
  for (const section of sections) {
    const sectionContent = await llm.generate(`
      生成 "${section}" 的详细内容（200字以内）
    `);
    content.push(sectionContent);
  }

  return content.join('\n\n');
}

// 总 token：2000 → 500-800 (节省 60-75%)

策略 7: 高级技术

2.7.1 Prompt Caching (模型缓存)

// 部分模型支持（如 Anthropic Claude）
const response = await anthropic.messages.create({
  model: "claude-3-sonnet-20240229",
  system: systemPrompt,  // 系统提示词会被缓存
  messages: conversation,
  cache_control: {
    system: { type: "ephemeral" }  // 标记可缓存
  }
});

// 优势：相同系统提示词的后续调用，token 成本降低 50%

2.7.2 语义缓存

class SemanticCache {
  private vectorStore: VectorDB;

  async findSimilar(query: string): Promise<string | null> {
    // 1. 向量化查询
    const embedding = await embed(query);

    // 2. 检索相似查询
    const similar = await this.vectorStore.search(embedding, topK=1, threshold=0.9);

    if (similar.length > 0) {
      return similar[0].response;
    }
    return null;
  }

  async save(query: string, response: string): Promise<void> {
    await this.vectorStore.insert({
      id: generateId(),
      embedding: await embed(query),
      response,
      timestamp: Date.now()
    });
  }
}

// 效果：相似查询的缓存命中率 20-40%
// Token 节省：20-40%

2.7.3 增量处理

// ❌ 重复处理完整上下文
const prompt1 = `
上下文：${fullContext}
任务：分析第一部分
`;

const prompt2 = `
上下文：${fullContext}
任务：分析第二部分
`;

// ✅ 增量处理
async function processIncrementally(context: string, tasks: string[]) {
  let state = {};
  const results = [];

  for (const task of tasks) {
    const prompt = `
    前序状态：${JSON.stringify(state)}
    新任务：${task}
    更新状态并返回结果。
    `;

    const result = await llm.generate(prompt);
    state = result.updatedState;
    results.push(result);
  }

  return results;
}

// Token 节省：50-70%

三、实施路线图

阶段 1: 基础优化 (1-2周)

- [ ] 提示词精简（目标：节省 30%）
- [ ] 上下文长度限制（目标：控制输入 token）
- [ ] 工具描述优化（目标：节省 50%）
- [ ] 基础缓存实现（目标：命中率 20%）

**预期效果：** 成本降低 30-40%

阶段 2: 智能优化 (2-4周)

- [ ] 智能上下文裁剪算法
- [ ] 对话摘要系统
- [ ] 向量检索 + 精排
- [ ] 分层模型选择

**预期效果：** 成本降低 50-60%

阶段 3: 高级优化 (4-8周)

- [ ] 语义缓存系统
- [ ] 知识图谱构建
- [ ] Prompt Caching 集成
- [ ] 完整监控和分析

**预期效果：** 成本降低 60-70%

四、监控与评估

4.1 Token 使用监控

interface TokenMetrics {
  totalTokens: number;
  inputTokens: number;
  outputTokens: number;
  cachedTokens: number;
  cost: number;
  savings: number;  // 相比基线的节省百分比
}

class TokenMonitor {
  private metrics: TokenMetrics[] = [];

  recordCall(call: LLMCall) {
    this.metrics.push({
      totalTokens: call.inputTokens + call.outputTokens,
      inputTokens: call.inputTokens,
      outputTokens: call.outputTokens,
      cachedTokens: call.cachedTokens || 0,
      cost: calculateCost(call),
      savings: calculateSavings(call)
    });
  }

  getReport(): MetricsReport {
    return {
      totalCalls: this.metrics.length,
      avgTokens: average(this.metrics.map(m => m.totalTokens)),
      totalCost: sum(this.metrics.map(m => m.cost)),
      avgSavings: average(this.metrics.map(m => m.savings)),
      topCostlyCalls: this.getTopCostlyCalls(10)
    };
  }
}

4.2 效果评估

interface EvaluationMetrics {
  cost: number;           // 成本
  latency: number;        // 延迟
  quality: number;        // 质量（0-1）
  satisfaction: number;  // 用户满意度（0-1）
  tokens: number;         // Token 使用量
}

async function evaluateAgent(
  agent: Agent,
  testCases: TestCase[]
): Promise<EvaluationMetrics> {
  const results = await Promise.all(
    testCases.map(async (testCase) => {
      const start = Date.now();
      const response = await agent.execute(testCase.input);
      const latency = Date.now() - start;

      const quality = await evaluateQuality(response, testCase.expected);
      const tokens = response.tokensUsed;

      return {
        cost: calculateCost(tokens),
        latency,
        quality,
        satisfaction: testCase.satisfaction || quality,
        tokens
      };
    })
  );

  return aggregateMetrics(results);
}

// 目标：
// - Cost 降低 60%
// - Latency 降低 40%
// - Quality 保持 > 0.85

4.3 A/B 测试

async function abTest(
  originalAgent: Agent,
  optimizedAgent: Agent,
  testCases: TestCase[]
) {
  const original = await evaluateAgent(originalAgent, testCases);
  const optimized = await evaluateAgent(optimizedAgent, testCases);

  const comparison = {
    costReduction: (original.cost - optimized.cost) / original.cost,
    latencyReduction: (original.latency - optimized.latency) / original.latency,
    qualityChange: optimized.quality - original.quality,
    tokenReduction: (original.tokens - optimized.tokens) / original.tokens
  };

  return comparison;
}

// 判断标准：
// - costReduction > 0.5  ✅
// - qualityChange > -0.1  ✅ (可接受的质量损失)

五、实战案例

案例 1: 代码审查 Agent

优化前：

Token 使用：3500 tokens/次
成本：$0.035/次
延迟：8s

优化后：

// 1. 提示词精简：500 → 100 tokens
const systemPrompt = "代码审查：简洁、准确、具体";

// 2. 结构化输出
const outputFormat = `JSON格式: {issues:[{type,line,severity,desc}],suggestions}`;

// 3. 分层模型
const model = await selectModel(complexity);

// 4. 缓存常见问题
const cached = await cache.findSimilar(code);

// 5. 增量处理
const incremental = await processIncrementally(code);

结果：

Token 使用：1200 tokens/次（节省 66%）
成本：$0.006/次（节省 83%）
延迟：3s（节省 62%）
质量：0.92 → 0.88（可接受）

案例 2: 客服问答 Agent

优化前：

Token 使用：5000 tokens/次
成本：$0.05/次
缓存命中率：5%

优化后：

// 1. 上下文裁剪
const context = await smartCrop(history, maxTokens=2000);

// 2. 知识库检索
const knowledge = await retrieveTopK(question, k=3);

// 3. 小模型预处理
const intent = await smallModel.classify(question);

// 4. 语义缓存
const cached = await semanticCache.findSimilar(question);

// 5. 迭代式回答
const answer = await generateIteratively(knowledge, intent);

结果：

Token 使用：1800 tokens/次（节省 64%）
成本：$0.008/次（节省 84%）
缓存命中率：35%
质量：0.95 → 0.93（基本持平）

六、工具与资源

6.1 Token 分析工具

工具	功能	链接
tiktoken	OpenAI Token 计数器	https://github.com/openai/tiktoken
LangSmith	Agent 调用追踪和分析	https://smith.langchain.com
Weights & Biases	ML 实验监控	https://wandb.ai
LlamaIndex Tokenizer	多模型 Token 分析	https://llamaindex.ai

6.2 成本计算器

// 简单的成本计算器
class CostCalculator {
  private prices: Record<string, {input: number, output: number}> = {
    'gpt-4.1': { input: 5, output: 15 },          // $/1M tokens
    'gpt-4o': { input: 2.5, output: 10 },
    'gpt-4o-mini': { input: 0.15, output: 0.6 },
    'claude-3-opus': { input: 15, output: 75 },
    'claude-3-sonnet': { input: 3, output: 15 },
    'claude-3-haiku': { input: 0.25, output: 1.25 }
  };

  calculate(model: string, inputTokens: number, outputTokens: number): number {
    const price = this.prices[model];
    return (inputTokens * price.input + outputTokens * price.output) / 1e6;
  }
}

// 使用
const calculator = new CostCalculator();
const cost = calculator.calculate('gpt-4o-mini', 1000, 500);
console.log(`Cost: $${cost}`);  // Cost: $0.00045

6.3 开源项目

LangChain: https://github.com/langchain-ai/langchain
AutoGPT: https://github.com/Significant-Gravitas/AutoGPT
CrewAI: https://github.com/joaomdmoura/crewAI
MemGPT: https://github.com/cpacker/MemGPT

七、最佳实践总结

✅ DO

持续监控：建立完善的 token 使用监控体系
渐进优化：从简单优化开始，逐步应用高级技术
效果评估：每次优化后进行质量评估
用户反馈：收集用户对质量的反馈
团队协作：确保开发、测试、运维都参与优化

❌ DON’T

过度优化：不要牺牲核心功能来节省 token
盲目缓存：不是所有内容都适合缓存
忽略质量：成本降低不能以质量大幅下降为代价
一刀切：不同场景需要不同的优化策略
忽视监控：没有监控就无法衡量优化效果

八、未来展望

8.1 模型能力

更长的上下文：100k+ tokens 的上下文窗口
更高效的模型：同等能力下更低的成本
更好的缓存：模型级别的智能缓存

8.2 技术趋势

端侧推理：本地运行小模型，降低云端成本
模型蒸馏：用大模型训练小模型
联邦学习：分布式优化，减少重复计算

8.3 行业标准

Token 消耗标准：行业基准和最佳实践
质量评估标准：统一的 Agent 质量评估体系
成本透明化：更清晰的计费和优化工具

总结

Token 优化是一个系统性工程，需要从多个维度入手：

提示词优化：精简、结构化、示例驱动
上下文管理：智能裁剪、分层记忆、对话摘要
工具调用优化：精简描述、智能选择、合并复用
知识库优化：向量检索、智能分块、知识图谱
模型选择：分层架构、混合使用、缓存重用
输出优化：结构化输出、长度限制、迭代生成
高级技术：语义缓存、增量处理、Prompt Caching

关键指标：

成本降低：30-70%
延迟降低：40-60%
质量保持：>85%

记住：优化的目标不是最少 token，而是最佳性价比！

发布日期：2026-04-15
作者：来顺
标签：Agent、成本优化、性能优化