Kimi K3 in practice: hands-on experience and a comparison with Claude Code

How did the author’s Kimi K3 experiment turn out?#

Kimi K3 launched on July 16, 2026. It has 2.8 trillion parameters, a million-token context window, open weights, and first place in a blind frontend comparison. I collected all the details about its architecture, benchmarks, and prices in the full review of Kimi K3 versus Claude Code, so I won’t repeat them here.

At the end of that review, I wrote: the risk is losing a day to setup; the payoff is a bill that drops from the second week onward. I ran the experiment on my own tasks.

The first few hours really are exciting. The model eagerly picks up a task, generates coherent frontend work, and doesn’t hesitate over large files. That’s why my first impression was a pleasant shock. The problems surfaced in long sessions, with multiple agents, through repeated rounds of edits, and in the evening at the terminal.

In the end, I rolled back. Here’s what led to that decision, with figures and links to primary sources so you can check everything for yourself.

Why do benchmarks show Kimi K3 beating Claude?#

Here are the benchmarks where Kimi K3 beats Claude Fable 5:

Every row compares against Claude Fable 5.

The figures are real. Across all 35 benchmarks, Claude Fable 5 wins 22, Kimi K3 wins twelve, and there is one tie.

More interesting is where Kimi K3 falls short. Its deficit on coding benchmarks is modest, at 4–5 points. It slips on knowledge and reasoning: on HLE, Claude pulls ahead by almost 10 points. That’s exactly where a long task hits a wall: first you have to understand, and only then can you write.

Moonshot puts it this way in the main section of its release post:

Why does Kimi K3 feel twice as slow in practice?#

The comparison uses Claude Opus 4.8, the Claude version with a complete speed run.

Kimi K3 responds sooner, so it subjectively seems quicker in a short chat. At work, time is spent on something else: how slowly the full response arrives. Here it loses by almost half, and on a long response the gap adds up to minutes.

Kimi Code advertises 180–260 tokens per second, and that figure looks convincing next to my 34.7. It refers to the previous generation’s speed build, K2.7 Code HighSpeed. Kimi K3 has no such build at all, and the independent benchmark measures Kimi K3 itself.

A session that breaks on the seventh error and burns tokens on repeated calls is a context-engineering failure; the model choice is secondary here.

Where do the tokens go if reasoning can’t be turned off?#

You can lower the effort level; the documentation lists three: low, high, and maximum. But reasoning cannot be turned off entirely: it explicitly says that reasoning and storage of its history are always enabled for Kimi K3. With direct API calls, the maximum level is set by default, and most wrapper programs don’t change it.

Each turn adds thousands of output tokens at $15 per million. Plus, Moonshot requires you to return the assistant’s entire message, including its reasoning history, and those output tokens become input tokens again on the next turn.

So you pay twice for the same reasoning: first when the model writes it, then when you send it back to the model.

On the overall index, Kimi K3 uses 21% fewer output tokens than its predecessor, K2.6. The model has become more economical compared with its own previous version. Claude still uses less on the same tasks.

The prompt “hi” is billed as 86 tokens. Under the hood, a hidden system prompt of about 85 tokens is present, and you pay for it on every request.

I have a separate review on how to calculate your usage and where to check your remaining balance: how many tokens Claude Pro and Max give you. The calculation logic is the same there; only the prices change.

What happens when the model gets stuck reasoning?#

It looks like this. The model starts thinking, but instead of developing its thought, the text slips into repetition: the same word, then fragments of syllables, endlessly. The task stalls while the token counter keeps spinning.

Reports in Moonshot’s issue trackers describe Kimi K3 trying to read the same file six times in a row, receiving the “no-op call, file hasn’t changed since the previous read” rejection seven times, and then ending the turn as if nothing had happened. Other reports list four varieties of the same kind of hang—reading, replacing, testing, and analysis.

Moonshot states the cause directly. The model was trained in a mode that preserves reasoning history, and it needs to receive its past reasoning back in full. If the history arrives incomplete, the model tries to reconstruct the answer, produces the same tool call, and starts another loop.

Why does a multi-agent setup fall apart on Kimi K3?#

The official Moonshot documentation states this plainly: their API does not yet support WebFetch. In other words, Claude Code, which normally goes online to fetch a page, can’t do that on Kimi K3. The workaround is to paste the content manually or connect a third-party tool.

Claude Code can load tools on demand and puts a service block of type tool_reference in the history. Kimi doesn’t accept this type and returns a 400. It does so silently, without naming either the field or the reason:

{"error":{"type":"invalid_request_error","message":"Invalid request Error"},"type":"error"}

For comparison, here’s what the same failure looks like on Anthropic’s native API, where the server at least names the field and lists the accepted types:

messages.166.content.0.tool_result.content.0: Input tag 'tool_reference' found
using 'type' does not match any of the expected tags: 'document', 'image',
'search_result', 'text'

The difference matters. It’s impossible to diagnose the first message: neither the client nor the person behind it can tell which block was rejected. That’s exactly what the authors of the reports complain about.

The consequence: in one reported session, this error appeared seven times. The session survived the first six; the seventh killed it for good: after that, even entering the plain text “continue” caused it to crash. The report notes separately that the session was nowhere near the context limit, so the “history was too long” explanation doesn’t hold.

Here’s a summary of the block types the Moonshot API accepts and rejects:

The word “compatible” here describes only the request format. Everything else differs: which block types are accepted, what the history must contain, and which tools are available at all.

What doesn’t carry over with Kimi K3?#

The limitations section of the release post says this verbatim:

The model’s developer is saying: use our client; we don’t guarantee how someone else’s behaves.

The second point in that same section explains one more thing I had attributed to the model’s stubbornness:

My CLAUDE.md was written for the opposite habit: ask, show a plan, and wait for confirmation. The instructions are still there, but they’re now being read by a model with a different temperament.

If you want to keep one rule file for several agents, I covered that setup separately: one instruction file for Claude Code, Codex, and Cursor.

How much did Kimi K3 really cost?#

First, the prices, which favor Kimi K3:

Kimi prices come from the context caching documentation; the right column shows Claude Opus 5 prices as of July 30, 2026.

Kimi’s cache is automatic, cannot be disabled, and is identified by the hash at the start of the request. Any edit to the system prompt or tool list clears the message cache completely.

Here’s what Claude Code does during a normal workday:

1. Connects and disconnects external tools as the task progresses.
2. Loads tools on demand when they’re needed.
3. Launches subagents with a different set of tools.
4. Adds the instruction file to the system prompt.
5. Rebuilds the history when compressing context.

Each item on this list resets the start of the request, and therefore the cache. Input tokens cost $3 per million again instead of 30 cents—ten times more. On top of that comes constant reasoning at $15 per million output tokens, and those same tokens return as input on the next turn. That’s how a model with a low listed price can produce a bill you don’t expect.

According to OpenCode’s aggregate data, across nearly 280,000 live sessions, an average Kimi K3 session costs $1.86 with an average volume of 3.1 million tokens. That figure depends on 93% of input tokens hitting the cache. Change the start of the request, and it no longer applies to you.

Kimi plans cost $19, $39, $99, and $199. The quota comes from a shared pool for the entire membership, resets weekly without carrying over unused amounts, and uses a rolling five-hour window.

The $99 plan’s coding quota is comparable to Anthropic’s $200 plan, which goes against my own position. Kimi is cheaper per token, but you can’t see that anymore in the evening’s bill.

Where is Kimi K3 objectively good?#

1. Frontend. First place in a blind comparison by live developers. It builds layouts neatly and with decent taste.
2. Volume. A million-token context window, and long files don’t faze it. Analyzing a large repository and mapping it out is its kind of task.
3. First response. Time to first token is half that of Claude. It’s noticeable and pleasant in a short conversation.
4. Price per token. About 60% of Claude Opus 5’s price. If the start of the request doesn’t change, this yields real savings on large, repetitive workloads.
5. Open weights. The model isn’t locked to one provider.

There’s a caveat about the last point. It’s unrealistic to run a model like this at home: even in compressed form, its weights measure in terabytes. Here, openness means independence from a single provider.

How to test all this yourself in one evening#

1. Set up access using the instructions. I described the three environment variables and model substitutions by tier in the Kimi K3 versus Claude Code review. Check the setup with the /status command: Kimi won’t appear in the model selection menu because it has a built-in list of aliases, and you don’t need to touch it.
2. Remove the old key. If you previously had ANTHROPIC_API_KEY set, remove it. Together with ANTHROPIC_AUTH_TOKEN, it causes a conflict and you’ll get an authorization error for no good reason.
3. Turn off deferred tool loading right away. Do it before the first run, not after the first session dies.
4. Don’t switch models mid-task. If you started on Kimi K3, finish on Kimi K3. The reverse is also true. This is a direct Moonshot requirement; I quoted it above.
5. Use a real task of your own. One you worked on yesterday, with all its mess and unfinished threads. A snake game won’t show the difference: it only appears over the long run.
6. Write down two figures. How many minutes it took and how much money you spent that evening. Compare it with a usual evening on Claude.
7. Track idle time separately. When the agent hangs, reads the same file in a loop, or responds with an error—that’s part of the cost too.

If the evening’s bill comes out higher than expected, it’s almost always the cache: count how many times the start of the request was reset that evening. The price per token has little to do with it.

What I ended up keeping#

A practical setup: send Kimi K3 to inspect the repository and give a second opinion, while leaving the main work to your familiar agent. This setup holds up because it doesn’t require moving the wrapper or breaking what already works.

You can put it this way: one complete task goes to Kimi K3; a long chain involving tools and subagents goes to Claude Code. The more switches between tools a task requires, the more it costs on Kimi K3 and the greater the chance of a broken session.

I have a separate review on how to assign roles to two agents without mixing them up: three ways to work with two agents.

Benchmarks answer the question “who is stronger in lab conditions?” Your evening’s bill and your list of completed work answer the question “who is stronger for you?” When those two answers differ, trust the second: you calculated it yourself, not the marketing department.

After looking at all this, I decided for myself: whatever people say about new models, a leader is still a leader. Claude Code remains my main engine.