Kimi K3.1 Pro vs Claude Opus 5.5: half the price, 0.7 points behind

In the Kimi K3.1 Pro vs Opus 5.5 matchup, Moonshot's model lands 0.7 points behind on Terminal-Bench 4.0 (65.7% vs 66.4%) and costs half: $2 / $10 per million tokens vs $4 / $20. It's the first time a model that promises open weights has come this close to Claude Opus 5.5 on the terminal benchmark.

Kimi K3.1 Pro shipped on Friday, Oct 23, and the timeline has already decided it's "free Opus." Hold on.

The catch lives in three places: who measured it, how many tokens it burns to get to the same answer, and the fact that the weights don't exist yet. In this post we separate what's verified, what Moonshot self-reported, and what's a promise, do the real cost math, and show how to test both on your own workload before you swap anything in production.

Living post. Moonshot promised open weights by 11/04/2026. This post will be updated that day with license, format and file sizes.

TL;DR

• What it is: Kimi K3.1 Pro, a post-trained version of Kimi K3 (MoE with 2.8T total parameters, 104B active), 1M context, text + image. Released 10/23/2026.
• Key benchmark (self-reported): Terminal-Bench 4.0 65.7% vs 66.4% for Opus 5.5. A 0.7-point gap.
• Cost: $2 / $10 per million tokens (input/output) vs $4 / $20 for Opus 5.5 ($8 / $40 in fast mode).
• Open weights: promised by 11/04/2026. License not announced.
• The catch: Moonshot measured it themselves, the model is verbose, and subscribers are complaining about quota burning out in minutes.
• Useful links: official announcement and OpenRouter page.

What shipped (verified)

K3.1 Pro is the first model in the K3.1 series. According to Moonshot's announcement, it's a post-train of Kimi K3 with "substantially larger post-training compute." The architecture is the same as K3: 2.8 trillion total parameters, 104 billion active per token. We broke that base down in the post about Kimi K3's open weights.

Where it already runs:

• Kimi app (web, iOS, Android, HarmonyOS).
• Kimi Work, the desktop app, from version 3.1.0.
• Kimi Code, selected with /model.
• API, with two IDs: kimi-k3.1-pro and kimi-k3.1-pro-highspeed.

The Highspeed variant is 2 to 3 times faster and, according to Simon Willison, costs twice as much. In other words: Kimi Highspeed costs the same as standard Opus 5.5. Keep that in mind, it comes back in the cost math.

1M token context. Text and image input. Zero Data Retention available for API customers. And on the Business plan it ships disabled by default: an admin has to turn it on.

Kimi K3.1 Pro vs Opus 5.5 on benchmarks: 65.7% vs 66.4% (self-reported)

This is where the headline comes from. On Terminal-Bench 4.0, the benchmark closest to "coding agent running real commands in a real terminal," Moonshot reports:

Source: Moonshot's announcement, covered by The Next Web, which makes a point of flagging: all the numbers are Moonshot's own and have not been verified.

Other numbers Moonshot published:

• BenchCAD (with tools): 92.7% vs 96.2% for Opus 5.5. Without tools, practically a tie: 72.8% vs 73.0%.
• Hallucination rate on Kimi Hallu Bench Hard (no tools): 5.4% vs 6.8% for Opus 5.5. Internal benchmark, and Moonshot itself warns it's a stress test, not an everyday error rate.
• Kimi Code Bench 3.0 Long-horizon (internal): 61.2%, up from K3's 55.95%.

All run with reasoning effort "max", temperature 1.0 and top-p 0.95.

Now the independent counterpoint. The Artificial Analysis aggregate index gives 55 to Kimi K3.1 Pro and 58 to Opus 5.5. Ahead of Fable 5.1, GPT-6 Astra and Gemini 4 Argon (all at 53), but not neck and neck with Opus. That's 3 points, not 0.7.

Honest reading: on the slice Moonshot picked, it's a statistical tie. On the independent aggregate, Opus is still comfortably ahead. Both facts are true at the same time, and that's exactly why a lab's benchmark is never enough reason to migrate.

Switching models every launch because a chart moved is the 2026 version of being tool-dependent. The people who win this game have their own evals, a harness that swaps providers through config, and a cost-per-task metric. That's the kind of thing the folks in the Clã Beer and Code build every week, live: agents, RAG and evals running in production, not in slides.

Kimi K3.1 Pro pricing: half the price is not half the bill

On paper:

Kimi prices via OpenRouter (moonshotai/kimi-k3.1-pro) and Simon Willison. For Opus 5.5, Anthropic's list price, which we already compared in the post Gemini 4 Argon vs Claude Opus 5.5.

Exactly half. But price per token is not price per task.

In the Hacker News thread, one commenter pointed out that Kimi used about 150M tokens to run the Artificial Analysis index, against a median of 87M. If that holds for your case, the model talks ~1.7x more to reach the same answer. Another user did the math and landed on a real advantage of ~2.5x in the best case, versus the "5x cheaper" going around on X, and often much less.

A simple simulation of one day of a coding agent, with 10M input tokens and 1M output tokens on Opus:

Opus 5.5:           10M × $4  + 1,0M × $20 = $40 + $20 = $60
Kimi K3.1 Pro:      10M × $2  + 1,7M × $10 = $20 + $17 = $37   (saída 1,7x mais verbosa)
Kimi Highspeed:     10M × $4  + 1,7M × $20 = $40 + $34 = $74
Opus 5.5 fast mode: 10M × $8  + 1,0M × $40 = $80 + $40 = $120

Three takeaways:

1. In agentic workloads, input dominates. That's where Kimi really saves.
2. Verbosity eats part of the output advantage. The 50% becomes about 38% in this example.
3. If you need speed, Highspeed costs more than standard Opus once verbosity is factored in. There's no free lunch.

And all of that is before caching, which changes the whole math on both sides. Run it with your own numbers.

Quota burn and the apology (X only)

This one matters and needs a disclaimer: as of publication, this information has only circulated on X, with no coverage from news outlets.

On X, Moonshot apologized for hard limits and accelerated quota burn on K3.1 Pro and announced it was refunding 25% of the monthly quota on all plans.

What you can confirm outside X are user reports. On Hacker News, subscribers say the $20 plan lasted "fifteen, maybe twenty minutes tops" before hitting the 5-hour limit, and a $40 subscriber also burned through it fast. Another says the quota has been shrinking since K2.7.

Add verbosity to that: the model talks a lot, quota is counted in tokens, and the subscription runs out before lunch is over. For app or Kimi Code use, this weighs more than the API price. The same HN thread argues that OpenAI and Anthropic subscriptions deliver more value than their APIs, and Kimi's doesn't.

Cyber capability reduced on purpose (self-reported)

This is the most interesting detail of the launch, and the least discussed.

Moonshot says it removed cyberattack data from mid-training and RL before the open-weight release, while keeping general coding data. The reason, as covered by The Next Web: open models can't be recalled once someone downloads them.

The numbers, all internal, on xdev-bench-hard (pass@3):

• K3.1 Pro as released: 81.0%.
• Same checkpoint without the reduction: 90.5%.
• Kimi K3: 33.3%.

Moonshot claims K3.1 Pro's cyber capability "remains behind that of frontier proprietary models" that have been publicly available for at least three months.

If you've used Kimi K3 to fix flaws that Codex and Fable refused, this is a signal of change. If your use case is authorized pentesting or vulnerability analysis, test first. The new model may be less capable exactly where the old one helped you.

Kimi K3.1 open weights by Nov 4 (promise)

"Full model weights will be released by Nov 4, 2026." It's in the announcement. License: not announced.

Track record helps calibrate. With K3, Moonshot announced on 7/16 and released the weights on 7/27, one day earlier than promised, under a modified MIT license. That counts in their favor. But until the files are on Hugging Face, it's a promise.

And even with weights, the hardware math is the same as K3: ~1.4 TB just to load the weights. The 104B active parameters help with speed, not memory. This isn't a laptop model. It's for people with a cluster, or for third-party providers to host it cheaper.

Two pieces of context you shouldn't ignore:

• In July, the White House accused Moonshot of using banned Nvidia chips and copying an Anthropic model to build K3, without publishing evidence (The Next Web). Then came Anthropic's report on Moonshot.
• On HN, users report that K3.1 Pro sometimes identifies itself as ChatGPT or Claude. That doesn't prove distillation (common chat data in training explains it too), but it's noise your legal team will ask about.

We mapped the regulatory risk for teams running it in production in Brazil in sanctions on open-source Chinese AI.

Hands-on: test both on your workload

A lab's benchmark answers the lab's question. You need to answer yours. The cheapest path is OpenRouter, which exposes both through the same OpenAI-compatible API.

Step 1: direct call to Kimi

curl https://openrouter.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "moonshotai/kimi-k3.1-pro",
    "messages": [
      {"role": "user", "content": "Escreva um teste Pest para um endpoint POST /orders que valida estoque."}
    ]
  }'

The response includes usage with input and output tokens. That's the field that matters for comparing cost per task, not the list price.

Step 2: swap models through config in Laravel

No if ($modelo === 'kimi') scattered across the codebase. The model becomes config:

// config/llm.php
return [
    'model' => env('LLM_MODEL', 'anthropic/claude-opus-5.5'),
    'base_url' => 'https://openrouter.ai/api/v1',
    'key' => env('OPENROUTER_API_KEY'),
];

// app/Services/LlmClient.php
use Illuminate\Support\Facades\Http;

class LlmClient
{
    public function chat(array $messages, ?string $model = null): array
    {
        $response = Http::withToken(config('llm.key'))
            ->timeout(120)
            ->retry(3, 2000, throw: false)
            ->post(config('llm.base_url').'/chat/completions', [
                'model' => $model ?? config('llm.model'),
                'messages' => $messages,
            ])
            ->throw()
            ->json();

        return [
            'content' => $response['choices'][0]['message']['content'],
            'input_tokens' => $response['usage']['prompt_tokens'],
            'output_tokens' => $response['usage']['completion_tokens'],
        ];
    }
}

Switching providers becomes one line in .env. So does rolling back.

Step 3: a 20-case eval with cost per task

Take 20 real tasks from your backlog (bug fixed, test written, migration reviewed) with objective acceptance criteria. Run them on both models and record hits and cost:

$precos = [
    'moonshotai/kimi-k3.1-pro' => ['in' => 2, 'out' => 10],
    'anthropic/claude-opus-5.5' => ['in' => 4, 'out' => 20],
];

foreach ($precos as $model => $p) {
    $acertos = 0;
    $custo = 0;

    foreach ($casos as $caso) {
        $r = app(LlmClient::class)->chat($caso['messages'], $model);
        $acertos += $caso['check']($r['content']) ? 1 : 0;
        $custo += ($r['input_tokens'] * $p['in'] + $r['output_tokens'] * $p['out']) / 1_000_000;
    }

    printf("%s: %d/%d acertos, US$ %.4f, US$ %.4f por acerto\n",
        $model, $acertos, count($casos), $custo, $custo / max($acertos, 1));
}

The metric that decides is cost per correct answer, not cost per token. A model that costs half but fails twice as often ends up more expensive, because the rework is yours.

Common mistakes in this test: running only 3 cases and drawing conclusions, comparing at different temperatures, and forgetting that Kimi's rate limit can cut off mid-batch (the retry above helps, but log it when it happens).

Limitations and gotchas

• Self-reported benchmark. The 65.7% vs 66.4% is Moonshot's. The only independent aggregate available says 55 vs 58.
• Verbosity. More output tokens eat part of the price advantage and, on subscription plans, burn quota.
• Unstable quota. The apology and the 25% refund only circulated on X. Don't build a daily workflow on a quota that changes every release.
• Cyber capability cut on purpose. Good for the ecosystem, possibly bad for your defensive security use case. Test it.
• Weights don't exist yet. And without an announced license, you don't know if you can host it commercially.
• Customer data. Moonshot's API offers Zero Data Retention for API customers. Via OpenRouter, check the policy of the provider serving the request. Without that, mask before you send.

Quick FAQ

Is Kimi K3.1 Pro better than Claude Opus 5.5?

No, based on the available data. It gets close on Terminal-Bench 4.0 (65.7% vs 66.4%, Moonshot's numbers) and sits 3 points behind on the Artificial Analysis index (55 vs 58). For a lot of coding tasks the tie is real. Its edge is price, not quality.

How much does Kimi K3.1 Pro cost?

$2 per million input tokens and $10 per million output tokens, on OpenRouter and Moonshot's API. The Highspeed variant costs double: $4 / $20, the same as standard Opus 5.5. Per HN, the real per-task advantage tops out around ~2.5x because of verbosity.

When will Kimi K3.1 open weights be released?

Moonshot promised them by 11/04/2026, with no license announced. With K3 it delivered one day early, under a modified MIT license. This post will be updated on 11/04 with whatever gets published.

Can I run Kimi K3.1 Pro locally?

In practice, not on a dev machine. It's 2.8T parameters and about 1.4 TB of memory just for the weights. The 104B active parameters speed up inference but don't reduce the memory you need. The realistic path is the API or a third-party provider hosting the weights.

Conclusion

Kimi K3.1 Pro is the closest open (or almost open) model to Opus we've seen. On the terminal slice, 0.7 points. On the aggregate, 3. Half the price per token, but not half the price per task.

What changes for builders: the gap between open and closed has become a question of cost and operations, not raw capability. If you have your own evals and swap models through .env, you capture those savings. If you migrate because of a launch chart, you discover the verbosity, the quota and the rate limit in production.

On 11/04 we'll be back here with the weights. Meanwhile, it's worth revisiting how Kimi K3 held up against Claude to see how much of K3.1's jump was post-training and how much was marketing.