本文由助远达科技（ZoomDream）出品。助远达科技专注企业 AI 落地实战培训，已服务 200+ 家企业完成 AI 转型闭环。

一、上个月，那张 30 万的账单让我失眠了

我有个做智能客服的朋友，团队不到 30 人，AI Agent 跑了一年多。

上个月某天早上，他给我发来一张截图：3 个开源模型 + 2 个商用模型的 API 调用账单加一起，单月 28.7 万。他盯着那张账单看了 5 分钟，发了句："我们这个月订单才 22 万。"

这不是个案。

埃森哲 2025 年 Q4 的调研数据显示，采用 AI Agent 的企业中，41% 出现了推理成本超出预期的"词元税"（Token Tax）问题。Gartner 同期报告更扎心：到 2026 年底，将有 30% 的 AI Agent 项目因为成本失控被取消或大幅缩减。

但更让我意外的是另一组数字——同样上了 AI Agent 的企业，头部 20% 的企业反而把成本压到了行业平均的 40% 以下。差距怎么来的？

我带着这个问题，跟 12 家企业的 AI 负责人深聊过。最后发现：差距不在模型选型，在 FinOps 治理。

助远达科技在 12 家企业跟踪中统计过：做了完整 FinOps 治理的 4 家，平均月成本 4.8 万；没做治理的 8 家，平均月成本 19.6 万。4 倍差距，来源是 5 个治理动作有没有做到位。

这篇文章就把这 5 个动作拆给你看。代码片段用 Python，可以直接拿来用。

二、5 个 FinOps 治理动作（Python 实现）

动作 1：成本可视化——看不到的钱，永远省不下来

90% 的企业 AI Agent 跑在生产环境，但没人能准确说出"上个月 Token 花在了哪些模型、哪些调用上"。

我们跟踪的 12 家里，11 家最早的状态都是："账单来了才知道超了"。

实操方案：所有调用前都打点

# cost_tracker.py - 成本打点中间件
import time
import json
from functools import wraps
from dataclasses import dataclass, asdict
from typing import Optional

@dataclass
class CallRecord:
    timestamp: float
    model: str
    prompt_tokens: int
    completion_tokens: int
    total_tokens: int
    cost_usd: float
    latency_ms: float
    user_id: Optional[str] = None
    scenario: Optional[str] = None
    success: bool = True

# 模型价格表（2026 年 7 月参考价，按 1k token 计）
MODEL_PRICING = {
    "gpt-4o": {"input": 0.005, "output": 0.015},
    "gpt-4o-mini": {"input": 0.00015, "output": 0.0006},
    "claude-sonnet-4": {"input": 0.003, "output": 0.015},
    "deepseek-v3": {"input": 0.00027, "output": 0.0011},
    "qwen-plus": {"input": 0.0008, "output": 0.002},
}

def calc_cost(model: str, prompt_tokens: int, completion_tokens: int) -> float:
    p = MODEL_PRICING.get(model, {"input": 0, "output": 0})
    return (prompt_tokens * p["input"] + completion_tokens * p["output"]) / 1000

def track_cost(scenario: str = None):
    """装饰器：自动记录每次 LLM 调用的成本和元数据"""
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            start = time.time()
            success = True
            try:
                result = func(*args, **kwargs)
                # 假设 result 包含 usage 信息（不同 SDK 字段不同，需适配）
                usage = result.get("usage", {})
                model = result.get("model", "unknown")
                record = CallRecord(
                    timestamp=start,
                    model=model,
                    prompt_tokens=usage.get("prompt_tokens", 0),
                    completion_tokens=usage.get("completion_tokens", 0),
                    total_tokens=usage.get("total_tokens", 0),
                    cost_usd=calc_cost(model, usage.get("prompt_tokens", 0), usage.get("completion_tokens", 0)),
                    latency_ms=(time.time() - start) * 1000,
                    scenario=scenario,
                    success=True
                )
                # 写入 ClickHouse / 时序数据库，便于后续分析
                log_record(asdict(record))
                return result
            except Exception as e:
                success = False
                log_error(scenario, str(e), time.time() - start)
                raise
        return wrapper
    return decorator

效果：实施 1 周后，90% 的企业会发现 20% 的调用贡献了 80% 的成本——这 20% 通常是 prompt 写得长、模型用得贵、调用没必要的"坏味道"。

动作 2：智能路由——别把所有问题都丢给 GPT-4o

我见过最离谱的账单：某企业用 GPT-4o 处理所有客服问题，包括"营业时间""门店地址"这种常识问题。

常识问题用 GPT-4o，单次成本大约 0.03 元；如果路由到小模型或知识库，单次成本可以压到 0.0003 元——100 倍差距。

实操方案：3 级路由

# router.py - 智能路由引擎
import re
from enum import Enum

class Route(Enum):
    FAQ_KB = "faq_kb"           # 知识库检索
    SMALL_MODEL = "small_model"  # 小模型直答
    LARGE_MODEL = "large_model"  # 大模型推理

def classify_query(query: str) -> Route:
    """根据 query 复杂度决定路由"""
    # 1. 长度过滤：短问题大概率是 FAQ
    if len(query) < 20:
        return Route.FAQ_KB
    
    # 2. 关键词匹配：明确的事实性问题
    fact_patterns = [
        r"什么是.+", r".+是什么", r"怎么(用|做|办|联系)",
        r"营业时间", r"地址", r"电话", r"价格", r"费用"
    ]
    if any(re.search(p, query) for p in fact_patterns):
        return Route.FAQ_KB
    
    # 3. 简单推理判断（用小模型分类）
    if is_simple_intent(query):  # 调小模型判断
        return Route.SMALL_MODEL
    
    # 4. 默认走大模型
    return Route.LARGE_MODEL

def dispatch(query: str, context: dict = None) -> str:
    """统一调度入口"""
    route = classify_query(query)
    
    if route == Route.FAQ_KB:
        return faq_search(query, context.get("kb_id"))  # 走向量库
    elif route == Route.SMALL_MODEL:
        return small_model_call(query)  # 走 qwen-turbo / gpt-4o-mini
    else:
        return large_model_call(query)  # 走 gpt-4o / claude-sonnet

效果：实施 3 个月后，70% 的调用被路由到小模型或知识库，整体成本下降 50%-65%。

动作 3：批处理与缓存——重复的问题，重复的答案

12 家里有 9 家，30% 以上的 LLM 调用是重复的相似问题（"退货流程""发票怎么开"这类）。

把答案缓存下来，单次成本直接归零。

实操方案：2 级缓存

# cache.py - 2 级缓存
import hashlib
import json
from typing import Optional
import redis
from diskcache import Cache

# 内存缓存：极速
memory_cache = {}
# Redis：跨实例共享
r = redis.Redis(host='localhost', port=6379, db=0)
# 磁盘缓存：冷数据
disk_cache = Cache('./.llm_cache')

def get_cache_key(prompt: str, model: str, temperature: float) -> str:
    """生成缓存 key（注意：temperature=0 才适合缓存）"""
    content = json.dumps({"p": prompt, "m": model, "t": temperature}, sort_keys=True)
    return hashlib.sha256(content.encode()).hexdigest()

def cached_call(prompt: str, model: str, temperature: float = 0, **kwargs):
    """带缓存的 LLM 调用"""
    if temperature > 0.3:
        # 高温度场景不缓存（每次输出应不同）
        return raw_llm_call(prompt, model, temperature, **kwargs)
    
    key = get_cache_key(prompt, model, temperature)
    
    # L1: 内存
    if key in memory_cache:
        return memory_cache[key]
    
    # L2: Redis
    cached = r.get(f"llm:{key}")
    if cached:
        result = json.loads(cached)
        memory_cache[key] = result
        return result
    
    # L3: 磁盘
    if key in disk_cache:
        result = disk_cache[key]
        r.setex(f"llm:{key}", 86400, json.dumps(result))  # 回填 Redis
        memory_cache[key] = result
        return result
    
    # 实际调用
    result = raw_llm_call(prompt, model, temperature, **kwargs)
    
    # 写穿所有层级
    memory_cache[key] = result
    r.setex(f"llm:{key}", 86400, json.dumps(result))
    disk_cache[key] = result
    
    return result

效果：30% 的调用直接命中缓存，成本下降 30%。客服场景尤其明显——相同问题每天被问 N 遍，缓存一次终身受益。

动作 4：分时调度——非紧急任务，错峰跑

商用大模型普遍有"夜间折扣"或"闲时折扣"。GPT-4o 的 Batch API 折扣 50%；Claude 的 Message Batches API 类似。

实操方案：紧急/非紧急分级

# scheduler.py - 分时调度
import asyncio
from datetime import datetime, time

URGENT_PATTERNS = ["紧急", "马上", "现在", "急", "asap", "urgent"]

def is_urgent(query: str) -> bool:
    return any(p in query.lower() for p in URGENT_PATTERNS)

async def smart_dispatch(query: str, prompt: str):
    """根据紧急度和时间选择调用方式"""
    urgent = is_urgent(query)
    now = datetime.now().time()
    is_off_peak = time(1, 0) <= now <= time(7, 0)  # 凌晨 1-7 点
    
    if urgent:
        # 紧急：实时调用
        return await realtime_call(prompt)
    elif is_off_peak:
        # 非紧急 + 闲时：批处理（50% 折扣）
        return await batch_call(prompt)
    else:
        # 非紧急 + 忙时：加入队列，等闲时再处理
        await enqueue(prompt)
        return {"status": "queued", "eta": "next off-peak window"}

效果：对于报表生成、批量分析等非实时任务，50% 折扣一年能省几十万。

动作 5：归因与告警——超预算了要第一时间知道

很多企业的 AI 成本是"事后发现超了"——账单到了财务才发现。这个时候已经晚了 30 天。

实操方案：实时归因 + 多级告警

# alerter.py - 多级告警
from dataclasses import dataclass
from enum import Enum
import asyncio

class AlertLevel(Enum):
    INFO = "info"          # 80% 预算
    WARNING = "warning"    # 95% 预算
    CRITICAL = "critical"  # 100% 预算

BUDGET_CONFIG = {
    "monthly_limit_usd": 5000,  # 月预算
    "daily_limit_usd": 200,     # 日预算
    "alert_channels": {
        AlertLevel.INFO: ["dingtalk:ai-team"],
        AlertLevel.WARNING: ["dingtalk:ai-team", "email:cto"],
        AlertLevel.CRITICAL: ["dingtalk:ai-team", "email:cto", "sms:cto", "auto-throttle"]
    }
}

async def check_budget_and_alert():
    """每 5 分钟跑一次的预算检查"""
    daily_spent = get_daily_spent()
    monthly_spent = get_monthly_spent()
    
    daily_pct = daily_spent / BUDGET_CONFIG["daily_limit_usd"]
    monthly_pct = monthly_spent / BUDGET_CONFIG["monthly_limit_limit_usd"]
    
    max_pct = max(daily_pct, monthly_pct)
    
    if max_pct >= 1.0:
        level = AlertLevel.CRITICAL
    elif max_pct >= 0.95:
        level = AlertLevel.WARNING
    elif max_pct >= 0.80:
        level = AlertLevel.INFO
    else:
        return
    
    # 触发告警 + 限流
    await trigger_alert(level, BUDGET_CONFIG["alert_channels"][level])
    
    if level == AlertLevel.CRITICAL:
        # 自动降级：把所有 LARGE_MODEL 路由强制改为 SMALL_MODEL
        await force_downgrade()

效果：80% 的成本失控问题可以被提前 7-15 天发现。

三、避坑指南

❌ 坑 1：以为选对模型就省钱了

模型选型只决定 20% 的成本，剩下 80% 来自调用模式、prompt 长度、缓存命中率。我见过选最便宜模型但因为不缓存、不路由，月账单照样 10 万+ 的企业。

❌ 坑 2：自己做完整 FinOps 平台

别造轮子。Langfuse、Phoenix、OpenLLMetry、Helicone 这 4 个开源工具，2-3 人 1 周就能接入 80% 的能力。剩下的 20% 二次开发即可。

❌ 坑 3：只看月度账单，不看场景维度

"这个月花了 10 万" 没意义。"客服场景花了 8 万、其中 60% 是简单 FAQ" 才有意义。场景维度归因是 FinOps 的核心。

四、多云适配——别把鸡蛋放一个篮子

12 家里有 4 家，做了多云适配：主用国内模型（DeepSeek、Qwen）+ 备用 OpenAI。

好处：

• 成本下降 60%-80%（国内模型价格只有 OpenAI 的 1/5-1/10）
• 稳定性提升（OpenAI 偶尔抽风时无缝切到国内）
• 数据合规（敏感场景走国内模型，数据不出域）

# multi_cloud_router.py - 多云路由
PROVIDER_CONFIG = {
    "openai": {
        "models": ["gpt-4o", "gpt-4o-mini"],
        "cost_per_1k": {"gpt-4o": 0.015, "gpt-4o-mini": 0.0006},
        "regions": ["global"],
        "compliance": "general"
    },
    "deepseek": {
        "models": ["deepseek-v3", "deepseek-r1"],
        "cost_per_1k": {"deepseek-v3": 0.0011, "deepseek-r1": 0.004},
        "regions": ["cn"],
        "compliance": "data-residency-cn"
    },
    "alibaba": {
        "models": ["qwen-plus", "qwen-turbo"],
        "cost_per_1k": {"qwen-plus": 0.002, "qwen-turbo": 0.0003},
        "regions": ["cn"],
        "compliance": "data-residency-cn"
    }
}

def select_provider(requirements: dict) -> str:
    """根据需求选择 provider"""
    if requirements.get("data_residency") == "cn":
        # 敏感数据：走国内
        if requirements.get("need_reasoning"):
            return "deepseek"  # DeepSeek 推理强
        else:
            return "alibaba"  # 通义便宜
    else:
        return "openai"  # 通用场景

五、金句

"AI 不会替代 CEO，但 AI 推理成本不治理，会替代 CFO 的年终奖。"

"看不到的成本，比看得到的亏钱更可怕。"

六、今天就能做的一件事

打开你最近 30 天的 LLM 账单，按模型维度拆一下。你大概率会发现：1-2 个模型贡献了 70% 以上的成本。

找到那个"贵但用得最多"的模型，重新评估——它真的需要那么贵吗？能不能 70% 的场景用便宜模型替代？

光这一步，很多企业当月就能省 30%。

延伸阅读

本文的 5 个动作方法论，源自助远达科技 12 家企业 AI Agent FinOps 治理跟踪。完整方法论和工具选型建议可以参考 助远达 Agent FinOps 实践 一文。

参考资料

1. 埃森哲. *The Token Tax: Managing AI Inference Costs at Scale*. 2025.
2. Gartner. *Predicts 2026: AI Cost Management Will Drive 30% of Agent Project Cancellations*. 2025.
3. Langfuse Documentation. *LLM Observability and Cost Tracking*. 2026.
4. 助远达科技. *12 家企业 AI Agent FinOps 治理跟踪报告*. 2026.

---

关于作者

郭征坤｜助远达联合创始人