Kimi K2 Thinking guide: reasoning agents, tool calls, and cost

Quick answer: what Kimi K2 Thinking is, and what runs today

Kimi K2 Thinking is Moonshot AI's open-weight reasoning model, released as part of the Kimi K2 line. Its defining trait is not a chat trick, it is the ability to interleave long chains of reasoning with tool calls: running searches, executing code, reading the results back into its own context, and deciding on the next step before it ever hands back a final answer. Moonshot reported the model chaining roughly 200 to 300 sequential tool calls in a single run without a human correcting course partway through, which is a different design target than a model built to answer one question well and stop. Reported specs put it in the trillion-parameter mixture-of-experts class, with roughly 32 billion parameters active per token and native low-bit quantization that keeps inference fast despite the size. The context window is 256K tokens. Because the weights shipped open, any team with enough GPU budget could self-host it, and its results on agentic and long-horizon reasoning benchmarks put it in the same conversation as proprietary reasoning models from Anthropic and OpenAI, at a fraction of the published per-token price of those alternatives. None of that changes how you call it. A reasoning agent built on this model line still speaks the same chat completions JSON as any other model: the same message roles, the same streaming behavior, and a tools array for the function-calling loop that makes it useful as an agent in the first place. The current release in that lineage is kimi-k2.6, a 256K-context model built for the same long tool-calling workloads, sitting in an OpenAI-compatible catalog next to Claude, GPT, DeepSeek, and Grok reasoning models so the same integration can route between all of them without a rewrite.

Where a reasoning agent actually spends its budget

None of this is unique to one model or one vendor. It is the shape of agentic reasoning workloads generally: a single user request can fan out into dozens of model calls, and the token math compounds with every step the agent takes before it decides to stop. The next section prices that out with concrete numbers instead of leaving it abstract.

• Thinking tokens count as output. The chain-of-thought a reasoning model produces before its final answer is billed the same as the visible reply, even though you rarely read it.
• Every tool call is a fresh round trip, and each one resends the growing conversation. A 40-step agent loop is not one request billed forty times bigger, it is forty separate requests, each carrying more context than the last.
• Tool results get appended, not summarized, by default. Search snippets, file contents, and function outputs pile into the context window and get re-billed as input on every later step.
• Retries inside the loop are invisible on the surface. A tool call that times out or returns malformed JSON often triggers a silent retry, another full round trip at whatever size the context has grown to by then.
• Parallel agent instances multiply everything above by however many are running at once, which is how a single afternoon of testing a new agent turns into a bill nobody sized ahead of time.

Worked example: pricing a tool-calling agent task

Model it step by step instead of guessing at a monthly total. Three profiles below cover a single reasoning question with no tools, a research agent running about 15 tool calls, and a long autonomous run pushing 150 tool calls before it stops. Context grows with every step, so later calls in a long run carry far more input tokens than the first one; the totals below are the sum across the whole run, not a single call. A single reasoning question with no tools runs roughly 2K input tokens and 3K output tokens, most of it thinking. A research agent doing about 15 tool calls, with context growing from a few thousand tokens on the first call to around 35K tokens by the last, averages close to 20K input tokens per call: 15 calls at 20K is 300K input tokens, plus roughly 1.5K output tokens per step for about 23K output tokens total. A long autonomous run pushing 150 tool calls before it stops, averaging around 35K input tokens per call as file reads and search results accumulate, is 5.25M input tokens, plus roughly 1.2K output tokens per step for about 180K output tokens total. The table below prices those three profiles on kimi-k2.6 against a premium reasoning alternative at direct catalog rates, so the gap is visible in dollars, not just in relative terms.

Why the invoice surprises people who only tested it once

The fix is rarely a different model by default. It is measuring cost per completed task instead of cost per token, and comparing that number across more than one candidate before committing a production workflow to it.

• A quick demo runs one or two tool calls and looks cheap. Production tasks that genuinely need the reasoning model run the loop until the job is actually done, which can be an order of magnitude more steps than the demo.
• Open-weight does not mean free to run. Self-hosting a trillion-parameter mixture-of-experts model needs enough GPU memory and throughput that most teams come out ahead paying per token through an API instead of buying the hardware.
• A model that is cheaper per token can still cost more per task if it needs more steps or a longer chain of thought to reach the same answer. Per-token price and per-task price are different numbers, and only the second one is on your invoice.
• Rate limits and queueing during a launch surge can stall a long tool-calling run mid-loop, and the partial run still billed for every step that already completed before it stalled.
• Teams that benchmark once on the official direct endpoint often skip testing the same workload through an alternate route, so they never learn whether a different model in the same price range finishes the task in fewer steps.

Kimi K2 Thinking vs the other ways to run a reasoning agent

Four practical approaches cover almost every team building on a reasoning model in this class. The right one depends on whether you need a feature only the native API exposes, whether you can realistically run your own inference infrastructure, and whether the task genuinely needs the strongest available reasoning or just a model that is good enough and cheap per step.

Fixing the runaway-loop problem

APIsRouter carries kimi-k2.6 alongside Claude, GPT, DeepSeek, and Grok reasoning models on one balance: pay-as-you-go with no subscription, global models priced 20% below official list, Chinese models priced below their official rates, and a first top-up that adds +100% balance. The table below prices the reasoning-capable models in that catalog so a routing test starts from real numbers instead of a guess.

• Set a hard step limit on the tool-calling loop and force a "give your best answer now" fallback prompt once it is hit, instead of letting the agent run until it decides to stop on its own.
• Summarize tool results before they re-enter context. Pasting a full search result page or file into the conversation on every step is usually the single biggest driver of the input-token line.
• Log tokens and tool-call count per completed task, not just per request, so a loop that is quietly running long shows up in a dashboard before it shows up on an invoice.
• Use a cheaper model for the tool-selection step and reserve the full reasoning model for the step that actually needs deep judgment; not every step in an agent loop needs the flagship.
• Cache the system prompt and tool schemas where your provider supports it, since both get resent unchanged on every single step of the loop.
• Route the same agent through an OpenAI-compatible gateway instead of a provider-specific SDK, so comparing a cheaper reasoning model against the one you started with is a model-field change, not a rewrite.

Calling a reasoning agent through one endpoint

The request shape does not change between models. Point the base URL at https://api.apisrouter.com/v1, set model to kimi-k2.6 (or swap in any other reasoning model in the catalog), and pass a tools array the same way you would for any OpenAI-compatible function-calling setup. The loop itself, the step limit, the summarization, the logging, all of it stays in your own code, not the API. The curl call below is a single turn with one tool defined. The Python snippet after it is the loop skeleton: it caps steps, forwards tool results back into the conversation, and forces a final answer if the model never stops calling tools on its own.

curl https://api.apisrouter.com/v1/chat/completions \
  -H "Authorization: Bearer sk-APIsRouter-..." \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k2.6",
    "messages": [
      {"role": "system", "content": "You are a research agent. Use tools when a question needs current information, and give a final answer once you have enough evidence."},
      {"role": "user", "content": "Compare the published context windows of three current reasoning models."}
    ],
    "tools": [
      {
        "type": "function",
        "function": {
          "name": "web_search",
          "description": "Search the web and return short snippets",
          "parameters": {
            "type": "object",
            "properties": {"query": {"type": "string"}},
            "required": ["query"]
          }
        }
      }
    ],
    "max_tokens": 800
  }'

FAQ