Kimi K3 深度评测：能力、成本与线路稳定性分析

Kimi K3 上线好像热度很高，也都在各种的讨论模型价格和能力，要不要换模型。

我觉得能力有没有进第一梯队，得先看长任务会吃多少 Token，换一条调用线路后还能不能稳定完成。

K3 值得做代码、长上下文和 Agent 测试，但还不适合只看榜单就直接替换生产模型。

1. 能力进了第一梯队，但不是全面第一

Moonshot 官方信息显示，Kimi K3 总参数量 2.8T，共 896 个专家、每次激活 16 个，上下文窗口为 1,048,576 Token。

官方 Coding 图里，它在 Program Bench 得分 77.8，略高于 GPT-5.6 Sol 的 77.6；但 DeepSWE 为 67.5，仍低于 GPT-5.6 Sol 的 73.0 和 Fable 5 的 70.0。

这个位置更像“有项目能赢的第一梯队”，不是全项目碾压。

2. 真正的成本，要把缓存和输出一起算

Kimi K3 官方 API 定价如下：

举个账单例子：一次任务输入 10 万 Token、输出 1 万 Token，不命中缓存约为 0.45 美元；输入命中缓存后约为 0.18 美元。差距很明显，但输出仍占大头。

Artificial Analysis 给 K3 的智能指数为 57，排在 187 个模型中的第 4 位，速度约 62 Token/秒；整套评测生成了 1.3 亿输出 Token，而同类中位数约 6300 万。

换句话说，它能力靠前，但有偏“话多”的成本风险。

3. 真实线路评测：同一个模型，结果也可能不同

一组 StackPerf 公开测试要求模型用 200 字解释长上下文推理成本，统一开启最高推理并限制 4096 Token 输出。

OpenRouter 转 Moonshot 跑 20 次，Kimi Code 直连跑 30 次。

前者重试期间记录到 311 次 HTTP 429，可见答案完成率 80%；后者没有 429，完成率 100%。中位总耗时分别为 68.81 秒和 60.47 秒，中位推理 Token 为 2592 和 2288。

4. 用代码复跑，而不是只看一张结果图

这组测试的任务是“用 200 字解释长上下文推理成本”，统一采用最高推理档和 4096 Token 输出上限。

下面的脚本可对任意兼容接口连续请求 10 次，直接记录 HTTP 状态、完成率、总耗时和 Token 用量；reasoning_effort 字段需要按具体线路文档调整。

import os
import statistics
import time
import json
import requests
from typing import Dict, List, Any
def make_request_with_retry(url: str, key: str, payload: Dict[str, Any], max_retries: int = 3) -> Dict[str, Any]:
"""发送请求，对 HTTP 429 状态码进行指数退避重试"""
retry_delay = 1  # 初始延迟 1 秒
for attempt in range(max_retries + 1):
started = time.perf_counter()
try:
response = requests.post(
url,
headers={"Authorization": f"Bearer {key}"},
json=payload,
timeout=180
)
elapsed = time.perf_counter() - started
        # 处理 429 状态码（速率限制）
        if response.status_code == 429:
            if attempt < max_retries:
                print(f"请求被限流 (429)，第 {attempt + 1} 次重试，等待 {retry_delay} 秒...")
                time.sleep(retry_delay)
                retry_delay *= 2  # 指数退避
                continue
            else:
                print(f"达到最大重试次数 ({max_retries})，请求失败")
                return {"status": 429, "done": False, "seconds": elapsed, "tokens": 0}
    # 处理其他 HTTP 错误
    if not response.ok:
        print(f"HTTP 错误: {response.status_code} - {response.text[:200]}")
        return {"status": response.status_code, "done": False, "seconds": elapsed, "tokens": 0}

    # 尝试解析 JSON
    try:
        data = response.json()
    except json.JSONDecodeError as e:
        print(f"JSON 解析错误: {e}")
        return {"status": response.status_code, "done": False, "seconds": elapsed, "tokens": 0}

    # 提取使用量和答案
    usage = data.get("usage", {})
    choices = data.get("choices", [{}])
    message = choices[0].get("message", {}) if choices else {}
    answer = message.get("content", "")

    return {
        "status": response.status_code,
        "done": bool(answer.strip()),
        "seconds": elapsed,
        "tokens": usage.get("total_tokens", 0),
        "answer": answer[:100]  # 记录答案前100字符用于调试
    }

except requests.exceptions.Timeout:
    print("请求超时 (180 秒)")
    return {"status": 0, "done": False, "seconds": time.perf_counter() - started, "tokens": 0}
except requests.exceptions.RequestException as e:
    print(f"请求异常: {e}")
    return {"status": 0, "done": False, "seconds": time.perf_counter() - started, "tokens": 0}
except Exception as e:
    print(f"未知错误: {e}")
    return {"status": 0, "done": False, "seconds": time.perf_counter() - started, "tokens": 0}
理论上不会执行到这里
return {"status": 0, "done": False, "seconds": 0, "tokens": 0}
def run_benchmark() -> None:
"""运行基准测试并输出结果"""
url = os.environ.get("API_URL")
key = os.environ.get("API_KEY")
model = os.getenv("MODEL", "kimi-k3")
prompt = "请用200字解释长上下文推理成本，并给出一个数字例子。"
if not url or not key:
print("错误: 请设置 API_URL 和 API_KEY 环境变量")
return
payload = {
"model": model,
"messages": [{"role": "user", "content": prompt}],
"reasoning_effort": "max",
"max_tokens": 4096,
}
rows = []
for i in range(10):
print(f"正在运行第 {i + 1}/10 次请求...")
result = make_request_with_retry(url, key, payload)
rows.append(result)
time.sleep(0.5)  # 避免请求过于密集
计算统计指标
completed = [r for r in rows if r["done"]]
completion_rate = len(completed) / len(rows) * 100 if rows else 0
total_time = sum(r["seconds"] for r in rows)
total_tokens = sum(r["tokens"] for r in rows)
status_counts = {}
for r in rows:
status = r["status"]
status_counts[status] = status_counts.get(status, 0) + 1
输出 Markdown 格式的统计表格
print("\n" + "="*60)
print("## 测试结果统计")
print("="*60)
print()
print("| 指标 | 值 |")
print("|------|-----|")
print(f"| 总请求次数 | {len(rows)} |")
print(f"| 成功完成次数 | {len(completed)} |")
print(f"| 完成率 | {completion_rate:.1f}% |")
print(f"| 总耗时 | {total_time:.2f} 秒 |")
print(f"| 平均每次耗时 | {total_time/len(rows):.2f} 秒 |")
print(f"| 总 Token 用量 | {total_tokens} |")
print(f"| 平均每次 Token | {total_tokens/len(rows):.0f} |")
print()
print("## HTTP 状态码分布")
print("| 状态码 | 次数 | 说明 |")
print("|--------|------|------|")
for status, count in sorted(status_counts.items()):
desc = {
200: "成功",
429: "速率限制",
0: "网络/超时错误"
}.get(status, "其他错误")
print(f"| {status} | {count} | {desc} |")
print()
print("## 详细请求记录")
for i, r in enumerate(rows):
status_desc = "成功" if r["done"] else "失败"
print(f"{i+1:2d}. 状态: {r['status']} ({status_desc}), "
f"耗时: {r['seconds']:.2f}s, Token: {r['tokens']}")
if name == "main":
run_benchmark()

实际比较时不要只看“请求成功”，还要把空答案、429 重试和总 Token 算进去。StackPerf 样本中，两条线路完成率相差 20 个百分点，这正是单次试用看不出的成本。

看 Kimi K3 的核心应该是：买到同名模型，不代表拿到同样的体验。实际选型时，可以先看价格、延迟和可用性，再用自己的固定提示词连续跑 10 次，记录成功率、首 Token 延迟、总耗时和 Token 消耗。

便宜但频繁重试的线路，最后往往并不便宜。

K3 适合长代码、研究资料和多工具 Agent；短问答、轻办公没必要为 1M 上下文付溢价。

模型是否值得用，最后看的是每个成功任务花了多少钱，而不是一次调用的标价。