Kimi K2 Thinking API Guide: Building Multi-Step Agents Without Losing Reasoning State

TL;DR

• Use kimi-k2-thinking when you want a dedicated always-thinking model for multi-step agents.
• Use kimi-k2.5 when you want a more flexible default that can enable or disable thinking.
• Keep reasoning_content in context, set max_tokens to at least 16000, keep temperature at 1.0, and prefer streaming.
• Moonshot's reviewed docs clearly support multi-step tool calls, but they do not publish a stable public "300-step" quota on the pages used for this rewrite, so your app should enforce its own loop limits.

What Moonshot's current docs actually confirm

Which Kimi route should you start with?

The implementation detail most guides miss

That matters because a multi-step agent is not one request. It is a loop:

1. The model reasons.
2. The model calls a tool.
3. Your app executes the tool.
4. The model reasons again using the prior tool result.

Minimal multi-step agent loop

This example is intentionally small. The point is to show the control flow that matters for Kimi's thinking models.

import json
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.moonshot.ai/v1",
    api_key=os.environ["MOONSHOT_API_KEY"],
)

tools = [
    {
        "type": "function",
        "function": {
            "name": "search_docs",
            "description": "Search internal product documentation",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string"}
                },
                "required": ["query"]
            }
        }
    }
]

messages = [
    {"role": "system", "content": "You are a careful research agent."},
    {"role": "user", "content": "Find the API limits for our billing service and summarize the risks."},
]

for _ in range(8):
    completion = client.chat.completions.create(
        model="kimi-k2-thinking",
        messages=messages,
        tools=tools,
        tool_choice="auto",
        temperature=1.0,
        max_tokens=16000,
    )

    message = completion.choices[0].message

    # Preserve the assistant turn exactly, including reasoning_content when present.
    messages.append(message.model_dump(exclude_none=True))

    if not message.tool_calls:
        print(message.content)
        break

    for tool_call in message.tool_calls:
        args = json.loads(tool_call.function.arguments)

        if tool_call.function.name == "search_docs":
            result = {"matches": ["rate_limit=500 rpm", "burst_limit=1000 rpm"]}
        else:
            result = {"error": "unknown tool"}

        messages.append(
            {
                "role": "tool",
                "tool_call_id": tool_call.id,
                "name": tool_call.function.name,
                "content": json.dumps(result),
            }
        )

Four rules that matter more than model marketing

Two more production notes are worth adding:

• Treat loop length as your policy. The reviewed docs say Kimi supports deep reasoning across multiple tool calls, but they do not expose a stable universal public step quota that should be hard-coded into a blog post.
• Validate tool arguments before you execute side effects. That part is implementation guidance, not a Moonshot guarantee, but it is the difference between a useful agent and an expensive retry loop.

Use Kimi K2 Thinking through EvoLink

from openai import OpenAI

client = OpenAI(
    base_url="https://api.evolink.ai/v1",
    api_key="YOUR_EVOLINK_API_KEY",
)

completion = client.chat.completions.create(
    model="kimi-k2-thinking",
    messages=[{"role": "user", "content": "Analyze the tradeoffs of event sourcing vs CRUD."}],
    temperature=1.0,
    max_tokens=16000,
)

Alternative: OpenClaw integration

If your runtime is OpenClaw rather than a direct API or EvoLink gateway, OpenClaw's Moonshot provider docs currently list:

• moonshot/kimi-k2.5
• moonshot/kimi-k2-thinking
• moonshot/kimi-k2-thinking-turbo

The documented onboarding shortcut is:

openclaw onboard --auth-choice moonshot-api-key
openclaw models list
openclaw models set moonshot/kimi-k2-thinking
openclaw models status

OpenClaw also documents binary native thinking control for Moonshot:

• /think off disables Moonshot thinking
• any non-off thinking level maps back to thinking.type=enabled

That is useful if you want one gateway that can switch between a cheaper non-thinking pass and a deeper reasoning pass.

A safer decision framework

FAQ

Is Kimi K2 Thinking the same as Kimi K2.5?

What breaks most multi-step Kimi agents?

Does reasoning_content count toward tokens?

Should I disable thinking for every simple task?

Can I use Kimi K2 Thinking through EvoLink?

Can I use Kimi K2 Thinking in OpenClaw?

Where should I publish pricing numbers from?

From Moonshot's live pricing pages, not from third-party benchmark tables or older comparison posts. This rewrite intentionally avoids hard-coded pricing claims because those values change faster than model-behavior guidance.

Try Kimi Through One Gateway

If you want to test Kimi alongside Claude, GPT, and other agent-friendly models without wiring each provider separately, use a gateway layer and verify the currently available routes before you publish a cost comparison.

Sources

• Moonshot thinking-model guide
• Moonshot API pricing index
• OpenClaw Moonshot provider docs