Moonshot Kimi K2 (0905 baseline) — 1T-param MoE chat model with 32B active per pass, 256k context, balanced performance.
Kimi K2.5 is a multimodal language model created by the provider Kimi. It accepts both text and image inputs and is designed to handle long-context tasks with a context window of 262,144 tokens. The…
Kimi K2.5 excels in long-context understanding with a 262K token window. It can process entire documents in one pass, enabling tasks like summarization, question answering, and information extraction across long texts. The image input capability allows multimodal reasoning—for example, describing a chart, reading text from a photo, or combining visual and textual data to answer complex questions. The high τ²-Bench score (95.9) indicates strong performance in tool-use and multi-step reasoning tasks, such as calling APIs, performing calculations, or browsing data.
You should select Kimi K2.5 when your task requires a large context window (over 32K tokens) or when you need to process images. If your task is purely text-based and fits within a 4K to 32K token window, a smaller model may be more cost-effective. Kimi K2.5’s strength in tool-use reasoning (evidenced by its τ²-Bench score) makes it a good fit for agentic workflows where the model must call external tools, handle multi-turn interactions, or follow complex instructions. For simple text generation or classification, a cheaper model may suffice.
Tasks that benefit most include: long-form document analysis (e.g., contract review, academic paper summarization), multimodal reasoning (e.g., image captioning, visual QA), agentic workflows (e.g., web automation, code generation with multiple steps), and tasks requiring consistent context over many turns (e.g., customer support chatbots handling extensive histories). The combination of large context and image input makes it especially useful for domains like healthcare (analyzing reports and images), legal (document review), and research (processing charts and publications).
Specific limitations are not provided, but as a large model, it may have higher latency compared to smaller models. The pricing per token is higher than some compact alternatives, so it may not be cost-efficient for very short prompts. Image input processing may consume many tokens, increasing cost. The model's performance on tasks not covered by the τ²-Bench benchmark is unverified. Users should test on their own data to confirm suitability. The model is accessed through OrcaRouter, which adds a standard API layer but no additional markup on provider pricing.
τ²-Bench is a benchmark designed to evaluate AI agents on real-world tool-use reasoning tasks. It tests a model's ability to understand instructions, plan steps, use external tools (e.g., calculators, search engines), and produce correct results. A score of 95.9 indicates that Kimi K2.5 performs very strongly on these practical reasoning tasks. However, this single number does not capture performance on other dimensions like creativity, factual accuracy, or multilingual support. The benchmark provides a useful reference for comparing models that are optimized for agentic workflows.
The only publicly provided benchmark figure for Kimi K2.5 is its τ²-Bench score of 95.9. No other benchmark numbers (e.g., MMLU, HumanEval) are available in the source facts. Therefore, direct comparisons cannot be made using this data alone. In general, a high τ²-Bench score suggests that Kimi K2.5 is competitive with other models designed for tool-use and multi-step reasoning tasks. Users should conduct their own evaluations on specific use cases to determine if it meets their performance requirements. OrcaRouter provides access to this model with no additional markup.
No specific latency or tokens-per-second figures are provided for Kimi K2.5. As a large model with a 262K token context window, inference time will generally be longer than for smaller models, especially for long prompts or high output token counts. Latency also depends on the hardware used by the provider (Kimi) and the current load on OrcaRouter's API. For real-time applications, users should test the model with their typical prompt sizes to determine acceptable response times. The pricing is per token, not per request, so no extra speed charges apply.
Kimi K2.5 is priced at $0.60 per 1 million input tokens and $3.00 per 1 million output tokens. These rates are billed at the provider rate with zero markup, meaning OrcaRouter passes through the exact cost from Kimi. There are no additional fees or tiered pricing. Input tokens include both text and image tokens. Output tokens are the generated response. Pricing is per token, so total cost depends on prompt and response length. There is no separate charge for image processing beyond the token count.
The provided facts do not mention any caching mechanisms or special pricing discounts for Kimi K2.5. OrcaRouter’s standard API does not include automatic prompt caching at this time. Users can optimize costs by carefully managing prompt length and reducing unnecessary tokens. For repetitive tasks, batching multiple queries into a single request may reduce total token usage. Since there is no markup on provider pricing, the model's cost is directly tied to token consumption. Consider using a smaller model for tasks that fit within a shorter context to save money.
The primary trade-off is between performance and cost. Kimi K2.5’s price per output token ($3.00/1M) is higher than many smaller models. For tasks requiring long outputs (e.g., full document generation), costs can accumulate quickly. However, the large context window may reduce the need for multiple API calls to handle long inputs, potentially saving overall expenses. The image input capability adds token consumption but may eliminate the need for separate image processing pipelines. Users should evaluate expected token volumes and compare with alternatives through OrcaRouter to find the best fit.
Kimi K2.5 is accessible via OrcaRouter's OpenAI-compatible API. The base URL is https://api.orcarouter.ai/v1. You must use the model identifier 'kimi/kimi-k2.5' in your requests. Authentication is done via an API key obtained from OrcaRouter. The API supports the same endpoints as OpenAI's Chat Completions API, including chat completions and streaming. Example: POST to /chat/completions with model: 'kimi/kimi-k2.5', messages array (content can include text and image URLs), and optional parameters like temperature, max_tokens (up to 32768), and stream.
The model supports standard parameters from the OpenAI Chat API: 'model', 'messages' (array with role and content), 'max_tokens' (default varies, max 32768), 'temperature' (default 0.7), 'top_p', 'stop', 'stream' (boolean), and 'frequency_penalty' and 'presence_penalty'. Image input is handled via content parts of type 'image_url' in the user message. The model respects the 262144 token context limit, so prompt+max_tokens must not exceed that. All other OpenAI parameters may be accepted but their effect depends on the underlying Kimi model.
Migration is straightforward because OrcaRouter's API is OpenAI-compatible. Simply change the base URL to https://api.orcarouter.ai/v1, your API key to an OrcaRouter key, and update the model name to 'kimi/kimi-k2.5'. If your existing code uses the openai Python library, you can set openai.api_base and openai.api_key. For chat completions, the message format remains the same; if you previously used image inputs with GPT-4V, the 'image_url' part format is identical. Adjust max_tokens if it exceeds 32768. No other changes are required for basic functionality.
Based on the provided facts, Kimi K2.5 offers a context window of 262,144 tokens, which is larger than typical models like GPT-4 (32K) but comparable to other long-context models such as Gemini 1.5 Pro (1M limit) or Claude 3.5 Sonnet (200K). Its pricing at $0.60/$3.00 per 1M tokens is competitive, and the zero markup from OrcaRouter keeps costs predictable. The τ²-Bench score of 95.9 suggests strong tool-use reasoning, but without additional benchmarks, a full performance comparison is not possible. Users should evaluate on their own tasks.
Smaller models on OrcaRouter (e.g., gpt-4o-mini or other compact models) generally have lower per-token cost, faster latency, and shorter context windows. They are suitable for simple tasks, classification, or short queries. Kimi K2.5, with its 262K context and image support, is better for complex reasoning, long documents, and multimodal inputs. The trade-off is higher cost per token and potentially slower response times. If your task does not require the large context or multimodal capabilities, a cheaper model will be more efficient. OrcaRouter makes it easy to switch between models for different use cases.
Kimi K2.5 is suitable for production if its capabilities match your requirements. The model is accessed through OrcaRouter, which provides reliable API infrastructure and standard OpenAI compatibility. The pricing at provider rate with zero markup is transparent. However, as with any third-party model, you should test for consistency, latency, and error handling under load. The τ²-Bench score suggests strong performance in tool-use scenarios, but production readiness also depends on factors like uptime, rate limits, and support from OrcaRouter. Contact OrcaRouter for specific SLAs and availability details.
OpenAI-compatible — keep the SDK you already use
https://api.orcarouter.ai/v1from openai import OpenAI
client = OpenAI(
base_url="https://api.orcarouter.ai/v1",
api_key="$ORCAROUTER_API_KEY",
)
response = client.chat.completions.create(
model="kimi/kimi-k2.5",
messages=[{"role": "user", "content": "Hello"}],
)
print(response.choices[0].message.content)frequency_penaltyinclude_reasoningmax_completion_tokensmax_tokensnpresence_penaltyprompt_cache_keyreasoningresponse_formatsafety_identifierstopstreamstream_optionstemperaturethinkingtoolstop_p| Input / 1M tokens | $0.600 |
| Output / 1M tokens | $3.00 |
| Cache read / 1M | $0.100 |
| Currency | USD |
Estimate based on list price
Estimate only — actual token counts depend on the provider's tokenizer.
GET /api/public/models/kimi/kimi-k2.5Open @misc{orcarouter_kimi_k2_5,
title = {kimi/kimi-k2.5 API},
author = {kimi},
year = {n.d.},
howpublished = {OrcaRouter},
url = {https://www.orcarouter.ai/models/kimi/kimi-k2.5}
}kimi. (n.d.). kimi/kimi-k2.5 API. OrcaRouter. https://www.orcarouter.ai/models/kimi/kimi-k2.5