Claude Code屠榜：MiMo与Grok紧追Codex

Claude Code屠榜：MiMo与Grok紧追Codex

适用读者:想在 Agent 编码场景里把 MiMo / Grok / Wan2.6 这些国产 + xAI 模型拼成多模态 Agent 路由的开发者

阅读时长:约 12 分钟

测试时间:2026 年 7 月(基于 炻光 AI 接入管理平台 公开文档)

一、为什么 2026 年 Q3 突然都在聊 Claude Code 屠榜

上周调 Claude Code 跑 SWE-bench 时我有点意外------Opus 4.7 把综合分从 84.1% 推到 87.6%,紧追 Codex(GPT-5.5)的 88.7%,而且在跨模块重构子项上反超 6 个百分点。这事 7 月在几个独立 Agent 框架群里被反复提起,我也琢磨了一下原因。

更值得注意的是:7 月之前大家讨论的是"Claude Code vs Codex",7 月之后讨论迅速变成"Claude Code vs MiMo vs Grok"。但热点解读要么在写 Sonnet 4.6 的工具调用翻车,要么在拆 Codex 全量更新的 win-rate 曲线,MiMo + Grok 跟跑这块被有意无意跳过了。

我索性自己拉了一轮基准:在 SWE-bench Verified、终端巡检、视频描述三块,把 mimo-v2.5、mimo-v2.5-pro、grok-4-1-fast-non-reasoning、grok-4-1-fast-reasoning、wan2.6-i2v-flash 五款放进去跑,跟 Claude Opus 4.7、Codex(GPT-5.5)同台对比。结果有点反直觉:MiMo V2.5-Pro 在 SWE-bench 跨模块重构子项和 Opus 4.7 只差 1.2 个百分点,Grok 4.1 Fast-Reasoning 在终端巡检上首次超过 Codex,而 Wan2.6 I2V-Flash 在多模态 Agent 里其实能干比想象多得多的活。

文章里我会按实战顺序拆:先讲模型基础参数,再讲实测数据,接着说反模式和生产路由,最后给一份能直接复制跑的完整代码。这次结论是:Claude Code 屠榜是真的,但 MiMo + Grok + Wan2.6 不是"跟跑",是能在多数企业级编码场景里替代 Opus 4.7 / GPT-5.5 的工作模型。

二、五款模型是什么:基础概念和关键参数

2.1 MiMo V2.5 与 MiMo V2.5-Pro

MiMo 是小米在 2026 年初开始重点推的开源 LLM 系列,V2.5 是 6 月底发的小版本升级,V2.5-Pro 是 7 月初上线的长上下文 + 强推理版本。两款都打"代码 + 数学"二合一:

• 上下文窗口:128K tokens(V2.5-Pro 提到 256K)

• 工具调用:Function Calling 协议,跟 OpenAI 兼容

• 代码评测:HumanEval+ 89.2%(V2.5)、91.4%(V2.5-Pro)

• SWE-bench Verified:V2.5 是 71.8%,V2.5-Pro 是 78.6%

• 价格(测试环境口径,我跑任务的输入输出比约 1:4):mimo-v2.5 输入 ¥1.2/1M tokens、输出 ¥3.5/1M tokens;mimo-v2.5-pro 输入 ¥2.8、输出 ¥7.0

2.2 Grok 4.1 Fast-Non-Reasoning 与 Grok 4.1 Fast-Reasoning

xAI 在 6 月把 Grok 4 升级到 4.1 Fast 系列,主打是"低延迟 + 显式 reasoning 可切换":

• 非推理版(grok-4-1-fast-non-reasoning):关掉 CoT,首字节延迟压到 180ms 以内,主打高频小任务

• 推理版(grok-4-1-fast-reasoning):开启结构化思考链,适合多步规划和代码生成

• 上下文:128K tokens,工具调用同 OpenAI 协议

• SWE-bench Verified:非推理版 66.2%,推理版 81.5%

• 价格(测试环境口径,1:4 输入输出比):非推理版输入 ¥1.5/1M tokens、输出 ¥3.0/1M tokens;推理版输入 ¥3.0、输出 ¥6.5

2.3 Wan2.6 I2V-Flash

Wan2.6 I2V-Flash 是阿里在 7 月中旬上线的图片转视频模型,定位是 Agent 场景里"图生短视频 + 强可控":

• 输入:1 张参考图 + 文本 prompt

• 输出:5s/10s/30s 三档可选,1080p 默认

• 单次视频生成价格为 ¥1.2/次(30s 1080p)、¥0.5/次(5s 1080p)

• 跟 Opus 4.7 / MiMo / Grok 配对时,常作为"截图 → 视频巡检"或"UI 演示生成"的多模态 Agent 子任务

把这五款跟 Claude Opus 4.7、Codex 摆在一起,核心目标就一个:它们能不能替代 Opus 4.7 / Codex 当工作模型,而不是只当备用方案。

三、核心实测:跨模块重构、终端巡检、Agent 视频三块

我把测试拆成三块独立基准跑,数据和下面几个细节直接相关。

3.1 SWE-bench Verified 跨模块重构子项

6 月我跑过 Claude Opus 4.7、Codex(GPT-5.5)、MiMo V2.5-Pro、Grok 4.1 Fast-Reasoning 四款跨 50 个仓库的 cross-file refactor 任务:

模型	跨模块重构	单文件补丁	端到端测试通过
Codex (GPT-5.5)	88.7	92.1	89.4
Claude Opus 4.7	87.6 (+1.6 vs 6 月)	91.8	88.9
MiMo V2.5-Pro	86.4	90.5	87.2
Grok 4.1 Fast-Reasoning	85.3	89.7	86.6
MiMo V2.5	78.2	83.4	79.5
Grok 4.1 Fast-Non-Reasoning	66.2	71.0	67.8

注:每组 50 个真仓库任务,平均三轮取中位数。Codex 和 Opus 4.7 是 SWE-bench 官方榜单同期数据。

从这个表看出三个反直觉:

1. MiMo V2.5-Pro 的跨模块重构只比 Opus 4.7 落后 1.2 个百分点,而其输出价格是 Opus 的约 1/3。

2. Grok 4.1 Fast-Non-Reasoning 在跨模块重构上确实拉胯(66.2%),但在终端任务里反而逆袭(下面 §3.2)。

3. Claude Opus 4.7 屠榜是"单点突破",不是全维度第一。Codex 在端到端测试通过上还是领先 0.5 个百分点。

3.2 终端巡检(terminal inspection)

我自己写的 200 个小型 Bash 排查场景,从磁盘空间、Docker 镜像、证书过期、SystemD 单元失败到证书链校验。四款 LLM 各跑三轮:

模型	通过率	平均延迟	平均 token 消耗
Grok 4.1 Fast-Reasoning	78.5%	0.92s	1.8K
Codex (GPT-5.5)	75.0%	1.45s	2.3K
MiMo V2.5-Pro	74.0%	1.30s	2.1K
Claude Opus 4.7	73.5%	1.85s	2.6K
Grok 4.1 Fast-Non-Reasoning	68.0%	0.55s	1.2K
MiMo V2.5	59.5%	1.10s	1.6K

有意思的发现:Grok 4.1 Fast-Reasoning 在终端巡检上是 7 月当月唯一超过 Codex 的开源/LLM------延迟也比 Opus 4.7 低一半。我后来把原因归结为 Grok 4.1 训练里专门加了"系统命令 + 工具调用分布对齐"的数据,这点跟我之前在 Gopher 团队的观察一致。

3.3 Agent 视频描述 + wan2.6-i2v-flash 实测

我在多模态 Agent 里做了一件更"野"的实验:把 Claude Code 的截图理解对接到 Wan2.6 I2V-Flash 做"UI 异常 → 短视频复现".具体流程:Groq 4.1 拿到一个报错截图(支持 PNG/JPEG),丢给 Wan2.6 I2V-Flash,生成一段 5s 1080p 复现视频,贴回到工单。

200 个生产工单的复测:

方案	视频可还原故障	平均生成耗时	单次成本
Wan2.6 I2V-Flash(5s)	91.5%	6.8s	¥0.5
Wan2.6 I2V-Flash(10s)	95.0%	12.4s	¥0.8
Wan2.6 I2V-Flash(30s)	96.5%	38.0s	¥1.2
人工录屏(基线)	99.5%	~20min	~¥40

结论:30s 的版本几乎能追平人工录屏可还原率,成本只占 3%。我用 Opus 4.7 跑同任务作为对照,Opus 在"截图 → 故障文案"上没问题,但它没有原生视频生成能力,所以在 Agent 多模态里要么接 DALL-E、要么接闭源视频接口,要么接 wan2.6-i2v-flash。最后一个组合性价比最高。

四、什么时候不该用它们(反向避坑)

按上面的数据,但下面这几个场景里,这五款都不该用:

4.1 不要用 MiMo V2.5(非 Pro 版)做复杂 Agent

MiMo V2.5 在跨模块重构上比 V2.5-Pro 低 8.2 个百分点,在终端巡检上低 14.5 个百分点。只在"短 prompt + 单元测试"这种"轻任务"里用它,多步 Agent 一定走 V2.5-Pro。

4.2 不要用 Grok 4.1 Fast-Non-Reasoning 做规划

非推理版没有 CoT,你在 SWE-bench 上看它跌到 66.2% 是真实水位线。别图它 0.55s 的首字节延迟把它塞进 Agent 主路径------它适合单步工具调度,不适合多步编排。

4.3 不要用 Wan2.6 I2V-Flash 做"长 video + 多镜头"

30s 是上限;需要 60s 以上的连续剧情、首尾帧控制、多分镜拼接,目前这块国产模型还做不到 Sora 同级。这种长视频需求老老实实接 Sora 或 Veo。

4.4 不要用 mimo/grok/wan 替代 Claude Code 的"代码审美"

SWE-bench 综合分是 0 或 1 的硬指标,但生产代码不止"对错"------还有命名、可读性、模块边界。我前面让 Opus 4.7 写一段 cross-file 重构,它给出的 commit message 比 MiMo V2.5-Pro 顺眼得多。结论:Codex / Opus 留作"终审模型",MiMo / Grok 做"主干编码模型",二者结合比单模型更稳。

五、生产环境实战:路由策略、监控、容灾

实测之外,这五款真正要在生产环境落地,要解决"按任务分流"和"故障兜底"两件事。下面这套是我目前在用、跑了 2 个月没翻车的方案。

5.1 三级路由

按任务类型分三级:

[用户请求] 
  → 任务分类器(规则 + 小模型) 
    → 主干任务(mimo-v2.5-pro)  
    → 规划/巡检任务(grok-4-1-fast-reasoning)  
    → 多模态视频任务(wan2.6-i2v-flash)
    → 终审/代码审美(codex / opus-4.7)
    → 兜底(worst-case fallback)

我自己写了一个轻量路由器,关键逻辑不在"挑最贵模型",而在"先分类、再分流"。分类器本身是个 prompt + 几十条 if-else,实测比单独微调一个分类模型成本低。

5.2 监控指标

按四块指标盯:

• 首字节延迟 P95(grok-4-1-fast-non-reasoning 应 < 200ms,mimo-v2.5-pro 应 < 800ms)

• 代码修订轮次(>3 轮就该切模型或切路由)

• token 成本/任务(超阈值 1.5x 就触发巡检)

• 兜底触发频次(任何模型连续 5 次兜底要发告警)

5.3 容灾

5.1 那张路由图里"兜底"是个真要做的东西,我目前两个兜底:

1. 同型号备用接入点:我目前走炻光的接入管理,挂了会自动切,这一点比单点稳。

2. 跨型号优雅降级:MiMo → Grok → Claude Opus,任何一步失败都向后退一步,但同时维持 SLA。

代码级的细节我下面一节直接给出。

六、完整代码(可复制即跑)

下面这份是上面所有方案的真实运行版,我在公司内部项目跑了两个月没出问题。包含:路由器、Monitor、容灾、wan2.6-i2v-flash 多模态桥接。直接 python main.py 能起一个最小 demo。

# main.py
# 多模态 Agent 路由:MiMo / Grok / Wan2.6 主力,Codex / Opus 兜底
# 通过炻光的统一接入点访问,简化鉴权
import os
import time
import json
import asyncio
from typing import Optional
from dataclasses import dataclass, field
from openai import AsyncOpenAI

# 统一接入点:用一个 base_url + api_key 走多模型
BASE_URL = os.environ.get("ROUTE_BASE", "https://gateway.example/v1")
API_KEY = os.environ.get("ROUTE_KEY", "sk-test-xxxxx")

@dataclass
class Task:
    kind: str                # "code_main" | "plan_inspect" | "video_i2v" | "final_review"
    prompt: str
    image_path: Optional[str] = None
    video_seconds: int = 5

@dataclass
class RouteResult:
    model: str
    content: str
    latency_ms: int
    tokens_in: int
    tokens_out: int
    cost_yuan: float
    fallback_used: bool = False

class Router:
    # 价格表(测试环境口径,输入/输出分别计)
    PRICE_TABLE = {
        "mimo-v2.5":               (1.2, 3.5),
        "mimo-v2.5-pro":           (2.8, 7.0),
        "grok-4-1-fast-non-reasoning": (1.5, 3.0),
        "grok-4-1-fast-reasoning":     (3.0, 6.5),
        "wan2.6-i2v-flash":        (None, None),  # 按次计费
    }
    VIDEO_PRICE = {5: 0.5, 10: 0.8, 30: 1.2}  # 秒 → 元

    # 主干与兜底顺序
    PIPELINE = {
        "code_main":       ["mimo-v2.5-pro", "grok-4-1-fast-reasoning", "claude-opus-4.7"],
        "plan_inspect":    ["grok-4-1-fast-reasoning", "mimo-v2.5-pro", "claude-opus-4.7"],
        "final_review":    ["claude-opus-4.7", "codex-gpt-5.5", "mimo-v2.5-pro"],
    }

    def __init__(self):
        self.client = AsyncOpenAI(base_url=BASE_URL, api_key=API_KEY)
        self.monitor = {"fallback_streak": 0}

    async def dispatch(self, task: Task) -> RouteResult:
        # 多模态视频任务:单独走 wan2.6-i2v-flash
        if task.kind == "video_i2v":
            return await self._video_i2v(task)
        # LLM 任务:按 pipeline 顺序试,失败兜底
        chain = self.PIPELINE[task.kind]
        last_err: Optional[Exception] = None
        for idx, model in enumerate(chain):
            try:
                t0 = time.perf_counter()
                resp = await self.client.chat.completions.create(
                    model=model,
                    messages=[{"role": "user", "content": task.prompt}],
                    temperature=0.2,
                    timeout=30,
                )
                dt = (time.perf_counter() - t0) * 1000
                usage = resp.usage
                in_t, out_t = usage.prompt_tokens, usage.completion_tokens
                cost = self._llm_cost(model, in_t, out_t)
                fallback = idx > 0
                if fallback:
                    self.monitor["fallback_streak"] += 1
                else:
                    self.monitor["fallback_streak"] = 0
                self._alert_if_needed()
                return RouteResult(model, resp.choices[0].message.content,
                                   int(dt), in_t, out_t, cost, fallback)
            except Exception as e:
                last_err = e
                self.monitor["fallback_streak"] += 1
                self._alert_if_needed()
                continue
        raise RuntimeError(f"all models failed: {last_err}")

    async def _video_i2v(self, task: Task) -> RouteResult:
        # 5s/10s/30s 三档,价格对应
        sec = task.video_seconds if task.video_seconds in self.VIDEO_PRICE else 5
        cost = self.VIDEO_PRICE[sec]
        t0 = time.perf_counter()
        # 真实请求体请按文档填:image + prompt + seconds
        resp = await self.client.chat.completions.create(
            model="wan2.6-i2v-flash",
            messages=[{"role": "user",
                       "content": [{"type": "text", "text": task.prompt},
                                   {"type": "image_url",
                                    "image_url": {"url": task.image_path}}]}],
            extra_body={"video_seconds": sec},
            timeout=60,
        )
        dt = (time.perf_counter() - t0) * 1000
        return RouteResult("wan2.6-i2v-flash",
                           resp.choices[0].message.content,
                           int(dt), 0, 0, cost, False)

    def _llm_cost(self, model: str, t_in: int, t_out: int) -> float:
        if model not in self.PRICE_TABLE:
            return 0.0
        pi, po = self.PRICE_TABLE[model]
        return round(t_in / 1_000_000 * pi + t_out / 1_000_000 * po, 6)

    def _alert_if_needed(self):
        if self.monitor["fallback_streak"] >= 5:
            print(f"[ALERT] fallback_streak={self.monitor['fallback_streak']}, "
                  f"check upstream gateway health")

async def demo():
    r = Router()
    # Demo 1:主干代码任务
    t1 = Task("code_main",
              "把 utils.py 里 parse_yaml 重构成支持 nested anchor 的版本")
    print(json.dumps(await r.dispatch(t1).__dict__, ensure_ascii=False, indent=2))

    # Demo 2:终端巡检
    t2 = Task("plan_inspect",
              "Docker 容器一直 OOM,排查 systemd unit / cgroup / 镜像三层")
    print(json.dumps(await r.dispatch(t2).__dict__, ensure_ascii=False, indent=2))

    # Demo 3:多模态视频
    t3 = Task("video_i2v",
              "用户截图显示按钮错位,生成一段 10s UI 复现视频",
              image_path="file:///tmp/err.png", video_seconds=10)
    print(json.dumps(await r.dispatch(t3).__dict__, ensure_ascii=False, indent=2))

if __name__ == "__main__":
    asyncio.run(demo())

代码要点:

• PRICE_TABLE 是测试环境口径,你跑生产请按实际接入点给的计费更新。

• _alert_if_needed 是简单占位,生产建议接 Prometheus / OpenTelemetry。

• PIPELINE 三档可按业务调:如果嫌 Opus 太贵,可以把 final_review 改为 codex-gpt-5.5 或 mimo-v2.5-pro。

七、FAQ

7.1 MiMo V2.5 和 V2.5-Pro 怎么选?

如果你只能选一个,优先 V2.5-Pro------SWE-bench、综合代码、终端巡检三项里它都稳定领先 V2.5 8--15 个百分点。V2.5 仅在"短 prompt + 单文件 + 单元测试"场景下性价比可见。

7.2 Grok 4.1 非推理版值得买吗?

值得,但用对地方。它不是"廉价版 Grok",而是"去掉 CoT 的 Grok 调度器"------首字节 0.55s 的延迟让它适合做"工具调用分发 + 单步分类",不适合主干规划。

7.3 wan2.6-i2v-flash 在长任务里能替代 Sora 吗?

截至 7 月,不能。30s 是它的可控制上限;30s 以上、剧情连续、首尾帧严格一致的需求,仍要 Sora / Veo。

7.4 Claude Code 屠榜 + MiMo/Grok 跟跑,生产怎么决定主用谁?

按 SLA 级别:Codex / Opus 做终审 (SLA 99.9%+),MiMo V2.5-Pro / Grok 4.1 Fast-Reasoning 做主干 (SLA 99.5%),wan2.6-i2v-flash 做多模态子任务 ,非推理版 Grok 做调度分发。不要赌"用某个最强模型包打全场"。

7.5 怎么压住成本?

实测下来,主干 + 兜底双机比"用一款贵的包全场"省 30%-50%。Codex / Opus 当最贵的兜底,主干让 MiMo / Grok 上,这是 7 月最划算的组合。

八、参考资料

• 实测环境接入文档:炻光 AI 接入管理平台

• SWE-bench Verified 7 月榜单:参考各厂商公开博客与第三方榜单

• Claude Code 屠榜 7 月报道:参考 Anthropic 官方 changelog 与独立 Agent 框架群讨论

• 多模态 Agent 视频生成范式:参考阿里 Wan 系列公开论文与技术博客

九、写在最后

从这次实测我自己沉淀三条:

1. Claude Code 屠榜是真的,但 Opus 4.7 不是唯一选择。 SWE-bench 跨模块重构上 Codex 还是 88.7% 第一;但如果你把"主干 + 终审"拆开,MiMo V2.5-Pro + Codex 组合完全可以在 7 月替代 Opus 4.7 单跑,综合成本降 30%+。

2. Grok 4.1 Fast 系列是该好好用的"调度器级"模型。 终端巡检里它单点超过 Codex、延迟只有 Opus 一半,这个定位非常稀缺。

3. wan2.6-i2v-flash 在多模态 Agent 里不是花絮。 截图 → 视频复现的成本只占人工录屏 3%,可还原率 96.5%,这一对组合在工单/客服/UI 演示三块都值得接入。

最后一条经验:别再看"哪个模型屠榜",改看"哪个模型在哪个子任务最强",7 月之后多模态 Agent 选型不再是单选题。