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 定价如下：

计费项	每百万 Token 价格
缓存命中输入	0.30 美元
常规输入	3.00 美元
输出	15.00 美元

举个账单例子：一次任务输入 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 上下文付溢价。

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