Kimi K2.5 is Moonshot AI’s native multimodal agent model, built by continued pretraining on approximately fifteen trillion mixed visual and text tokens over Kimi K2 Base. It combines language and vision with conversational and agent workflows. The input may contain text, images and video; the output is text such as an explanation, code or proposed tool operation.
The maker summary lists a mixture-of-experts architecture with one trillion total parameters and 32 billion activated parameters, a 256K context and a 400-million-parameter MoonViT visual encoder. K2.5 adopts the native INT4 quantization method documented for K2 Thinking. These are properties of the published producer checkpoint, distinct from an assertion about every surrounding execution configuration.
A defining use case is code generation from visual specifications, including interface designs and video workflows. Supply readable media, relevant source code and the intended behaviour. Identify which visual details are mandatory and how the result should respond to user interaction. A useful brief is: “Implement the supplied layout, preserve these labels and explain how the visible states correspond to the requirements.”
For an image-analysis task, ask for the visible detail supporting each finding and separate extraction from interpretation. For video, state the segment and the action or change to explain. The producer marks its demonstrated video workflow as experimental; understanding the media produces a textual result rather than rendering a new video or executing a visual action by itself.
K2.5 supports thinking and instant modes. Thinking develops reasoning before a final response; instant mode answers directly. The manufacturer’s reference deployment recommends temperature 1.0 for thinking, 0.6 for instant and top-p 0.95. Set the desired answer form separately from that reasoning choice, such as an extracted record, a decision memo or a complete code artifact.
For a difficult question, provide the full condition and relevant sources. A document brief can request a comparison with the supporting passage beside each conclusion. A coding brief can identify the failing input, constraints and change to propose. The output should remain traceable to that task rather than treating a long reasoning trace as a completed result.
K2.5 uses the same interleaved thinking and multi-step tool-call design as K2 Thinking. The application supplies functions with descriptions and schemas, executes selected operations and returns observations. Keep the results associated with their calls so the next step can use actual evidence.
The producer also describes an agent-swarm workflow that decomposes a complex goal into coordinated domain-specific subtasks. Prepare such a goal with defined outputs, allowed actions and criteria for completion. The final artifact should integrate the observations that were actually obtained; a generated plan or a proposed branch is distinct from executed work.
Budget the source, media representation, history, reasoning and final answer within the documented 256K context. The example request and evaluation token budgets in the card are not independently established universal output caps. Label sources and media so a result can refer back to its evidence.
The useful deliverable is an image-grounded explanation, code proposal or source-backed analytical result. Review values against the inputs and inspect code in its intended application. K2.5 remains its own multimodal release; later K2.6 preserve-thinking controls and earlier text-only K2 prompting profiles should not be substituted for this edition’s documented workflow.
", "aboutText": "Kimi K2.5 is Moonshot AI’s native multimodal agent model, built by continued pretraining on approximately fifteen trillion mixed visual and text tokens over Kimi K2 Base. It combines language and vision with conversational and agent workflows. The input may contain text, images and video; the output is text such as an explanation, code or proposed tool operation.\n\n### Model profile\n\nThe maker summary lists a mixture-of-experts architecture with one trillion total parameters and 32 billion activated parameters, a 256K context and a 400-million-parameter MoonViT visual encoder. K2.5 adopts the native INT4 quantization method documented for K2 Thinking. These are properties of the published producer checkpoint, distinct from an assertion about every surrounding execution configuration.\n\n### Coding with visual evidence\n\nA defining use case is code generation from visual specifications, including interface designs and video workflows. Supply readable media, relevant source code and the intended behaviour. Identify which visual details are mandatory and how the result should respond to user interaction. A useful brief is: “Implement the supplied layout, preserve these labels and explain how the visible states correspond to the requirements.”\n\nFor an image-analysis task, ask for the visible detail supporting each finding and separate extraction from interpretation. For video, state the segment and the action or change to explain. The producer marks its demonstrated video workflow as experimental; understanding the media produces a textual result rather than rendering a new video or executing a visual action by itself.\n\n### Thinking and instant responses\n\nK2.5 supports thinking and instant modes. Thinking develops reasoning before a final response; instant mode answers directly. The manufacturer’s reference deployment recommends temperature 1.0 for thinking, 0.6 for instant and top-p 0.95. Set the desired answer form separately from that reasoning choice, such as an extracted record, a decision memo or a complete code artifact.\n\nFor a difficult question, provide the full condition and relevant sources. A document brief can request a comparison with the supporting passage beside each conclusion. A coding brief can identify the failing input, constraints and change to propose. The output should remain traceable to that task rather than treating a long reasoning trace as a completed result.\n\n### Interleaved tools and agent tasks\n\nK2.5 uses the same interleaved thinking and multi-step tool-call design as K2 Thinking. The application supplies functions with descriptions and schemas, executes selected operations and returns observations. Keep the results associated with their calls so the next step can use actual evidence.\n\nThe producer also describes an agent-swarm workflow that decomposes a complex goal into coordinated domain-specific subtasks. Prepare such a goal with defined outputs, allowed actions and criteria for completion. The final artifact should integrate the observations that were actually obtained; a generated plan or a proposed branch is distinct from executed work.\n\n### Context and review\n\nBudget the source, media representation, history, reasoning and final answer within the documented 256K context. The example request and evaluation token budgets in the card are not independently established universal output caps. Label sources and media so a result can refer back to its evidence.\n\nThe useful deliverable is an image-grounded explanation, code proposal or source-backed analytical result. Review values against the inputs and inspect code in its intended application. K2.5 remains its own multimodal release; later K2.6 preserve-thinking controls and earlier text-only K2 prompting profiles should not be substituted for this edition’s documented workflow.", "editorialOverlay": { "copy_fields": { "practical_html": "Technical example in English
Draft an accessible tab interaction\n\nProvide HTML and JavaScript for three text-only tabs: Overview, Details and Returns. Exactly one panel is visible. Mouse clicks and Left/Right arrow keys change tabs; Home selects the first and End the last. Preserve those labels and include the key accessibility attributes. Return the bounded component and a short interaction-check list without claiming execution.A self-contained tab component proposal and checks for click, arrow, Home and End behavior.The selected tab, focus behavior and visible panel remain consistent after each supported interaction.moonshotai/kimi-k2.5Kimi K2.5 is Moonshot AI’s native multimodal agent model for image-grounded coding, reasoning and tool-assisted work. It combines text, images and video with thinking and instant modes, a 256K context and a producer workflow for coordinated agent subtasks.
This description covers the model’s capabilities. Available in Ailoot inputs, outputs and options are listed for the selected method below.
Kimi K2.5 is Moonshot AI’s native multimodal agent model, built by continued pretraining on approximately fifteen trillion mixed visual and text tokens over Kimi K2 Base. It combines language and vision with conversational and agent workflows. The input may contain text, images and video; the output is text such as an explanation, code or proposed tool operation.
The maker summary lists a mixture-of-experts architecture with one trillion total parameters and 32 billion activated parameters, a 256K context and a 400-million-parameter MoonViT visual encoder. K2.5 adopts the native INT4 quantization method documented for K2 Thinking. These are properties of the published producer checkpoint, distinct from an assertion about every surrounding execution configuration.
A defining use case is code generation from visual specifications, including interface designs and video workflows. Supply readable media, relevant source code and the intended behaviour. Identify which visual details are mandatory and how the result should respond to user interaction. A useful brief is: “Implement the supplied layout, preserve these labels and explain how the visible states correspond to the requirements.”
For an image-analysis task, ask for the visible detail supporting each finding and separate extraction from interpretation. For video, state the segment and the action or change to explain. The producer marks its demonstrated video workflow as experimental; understanding the media produces a textual result rather than rendering a new video or executing a visual action by itself.
K2.5 supports thinking and instant modes. Thinking develops reasoning before a final response; instant mode answers directly. The manufacturer’s reference deployment recommends temperature 1.0 for thinking, 0.6 for instant and top-p 0.95. Set the desired answer form separately from that reasoning choice, such as an extracted record, a decision memo or a complete code artifact.
For a difficult question, provide the full condition and relevant sources. A document brief can request a comparison with the supporting passage beside each conclusion. A coding brief can identify the failing input, constraints and change to propose. The output should remain traceable to that task rather than treating a long reasoning trace as a completed result.
K2.5 uses the same interleaved thinking and multi-step tool-call design as K2 Thinking. The application supplies functions with descriptions and schemas, executes selected operations and returns observations. Keep the results associated with their calls so the next step can use actual evidence.
The producer also describes an agent-swarm workflow that decomposes a complex goal into coordinated domain-specific subtasks. Prepare such a goal with defined outputs, allowed actions and criteria for completion. The final artifact should integrate the observations that were actually obtained; a generated plan or a proposed branch is distinct from executed work.
Budget the source, media representation, history, reasoning and final answer within the documented 256K context. The example request and evaluation token budgets in the card are not independently established universal output caps. Label sources and media so a result can refer back to its evidence.
The useful deliverable is an image-grounded explanation, code proposal or source-backed analytical result. Review values against the inputs and inspect code in its intended application. K2.5 remains its own multimodal release; later K2.6 preserve-thinking controls and earlier text-only K2 prompting profiles should not be substituted for this edition’s documented workflow.
POST /v1/chat/completionstexttext| Field | Type | Requirement | Values & limits | Default |
|---|---|---|---|---|
Fieldmodel | Typestring | RequirementRequired | Values & limits moonshotai/kimi-k2.5 | Default— |
Fieldmessages | Typemessage[] | RequirementRequired | Values & limits Minimum items: 1 | Default— |
Fieldmessages[].role | Typestring | RequirementRequired | Values & limits Examples: system, user, assistant, tool, function Conditions: These roles are explicitly represented by Source compatibility types; the exact model role set remains model-specific. Model-specific | Default— |
Fieldmessages[].content | Typestring|content_part[]|null | RequirementOptional | Values & limits | Default— |
Fieldmessages[].tool_calls | Typetool_call[] | RequirementOptional | Values & limits | Default— |
Fieldmessages[].tool_call_id | Typestring | RequirementOptional | Values & limits Applies when: role=tool; use actual returned ID | Default— |
Fieldmessages[].name | Typestring | RequirementOptional | Values & limits | Default— |
Fieldmessages[].reasoning_content | Typestring | RequirementOptional | Values & limits Applies when: Round-trip actual returned reasoning where this model uses it | Default— |
Fieldmessages[].reasoning_details | Typeobject|array | RequirementOptional | Values & limits Model-specific | Default— |
Fieldmax_tokens | Typeinteger | RequirementOptional | Values & limits Minimum: 1 Model-specific | Default— |
Fieldmax_completion_tokens | Typeinteger | RequirementOptional | Values & limits Minimum: 1 Model-specific | Default— |
Fieldstream | Typeboolean | RequirementOptional | Values & limits | Defaultfalse |
Fieldstream_options.include_usage | Typeboolean | RequirementOptional | Values & limits Model-specific | Default— |
Fieldtemperature | Typenumber | RequirementOptional | Values & limits Model-specific | Default— |
Fieldtop_p | Typenumber | RequirementOptional | Values & limits Model-specific | Default— |
Fieldstop | Typestring|string[] | RequirementOptional | Values & limits Model-specific | Default— |
Fieldtools | Typefunction_tool[] | RequirementOptional | Values & limits Model-specific | Default— |
Fieldtools[].type | Typestring | RequirementOptional | Values & limits function Model-specific | Default— |
Fieldtools[].function.name | Typestring | RequirementRequired | Values & limits Applies when: function tool supplied | Default— |
Fieldtools[].function.description | Typestring | RequirementOptional | Values & limits | Default— |
Fieldtools[].function.parameters | TypeJSON_schema | RequirementOptional | Values & limits | Default— |
Fieldtool_choice | Typestring|object | RequirementOptional | Values & limits Model-specific | Default— |
Fieldparallel_tool_calls | Typeboolean | RequirementOptional | Values & limits Model-specific | Default— |
Fieldresponse_format | Typeobject | RequirementOptional | Values & limits Model-specific | Default— |
Fieldreasoning_effort | Typestring | RequirementOptional | Values & limits Model-specific | Default— |
Fieldreasoning | Typeobject | RequirementOptional | Values & limits Model-specific | Default— |
Fieldservice_tier | Typestring | RequirementOptional | Values & limits Model-specific | Default— |
Fieldinstructions | Typestring | RequirementOptional | Values & limits Compatibility field | Default— |
Fieldfunctions | Typefunction[] | RequirementOptional | Values & limits Model-specific | Default— |
Fieldfunction_call | Typestring|object | RequirementOptional | Values & limits Model-specific | Default— |
Fieldprompt_cache_options | Typeobject | RequirementOptional | Values & limits Model-specific | Default— |
Fieldmodalities | Typestring[] | RequirementOptional | Values & limits text | Default— |
Fieldprovider | Typeobject | RequirementOptional | Values & limits Conditions: provider.options is rejected on this Ultra text route | Default— |
Fieldcache_control.ttl | Typestring | RequirementOptional | Values & limits Conditions: 1h is rejected in actual prompt-cache locations | Default— |
Text · UTF8 text
messages[].content
| Parameter | Contract |
|---|---|
Parametercontent_type | Contractapplication/json |
Parameterrequired | Contractmodel, messages |
Parametermaterial_types | Contracttext |
Parametermessages | Contractmessage array with role/content shape |
Parameterfile_material | Contractactual UTF-8 document inserted as literal text; no file ID inferred |
Parameteroptional_controls | Contractstream, temperature, top_p, stop, max_tokens, max_completion_tokens, reasoning, response_format, tools, tool_choice |
Parametercontrol_scope | Contractmodel-specific; user function tools differ from hosted tools |
Parameteroutput_modalities | Contracttext |
Parameterhosted_operations | Contractfalse |
Parametermultimodal_input_binding | Contractnull |
Lifecycle: synchronous_or_streamed
Send exact model ID with messages.
Context length is not an output cap.
A text file may supply literal text; image/audio/file-object inputs need exact binding.
Tariff references do not add request options. Supported parameters are listed for the selected method.
Match each charge to the conditions shown. Use one rate for each set of alternative configurations.
| Configuration | Rate schedule | Context tokens, more than | Context tokens, up to and including | Charge |
|---|---|---|---|---|
| ConfigurationBase token rates | Rate scheduleBase rate | Context tokens, more than— | Context tokens, up to and includingNo upper bound | Charge Input · Input tokens $0.0012 / 1K tokens Output · Output tokens $0.006 / 1K tokens Input · Cache read $0.0003 / 1K tokens Input · Cache write $0 / 1K tokens Input · Cache write, 1 hour — / 1K tokens |
| ConfigurationRequest-length tier 1 | Rate schedule— | Context tokens, more than0 | Context tokens, up to and includingNo upper bound | Charge Input · Input tokens $0.0012 / 1K tokens Output · Output tokens $0.006 / 1K tokens Input · Cache read $0.0003 / 1K tokens Input · Cache write $0 / 1K tokens Input · Cache write, 1 hour — / 1K tokens |
Ailoot reserves an estimated amount before a request. After the result, it settles the final charge from measured usage. Streaming settlement uses the final usage record. How reservation and settlement work →
set -eu\n: "${AILOOT_API_KEY:?Set your Ailoot API key}"\npython3 - <<'PY_REQUEST'\nimport json,os\nfrom pathlib import Path\np=json.loads('{"model": "moonshotai/kimi-k2.5", "messages": [{"role": "user", "content": "Explain the difference between an observation and a hypothesis in three sentences."}]}')\n\nPath("request.json").write_text(json.dumps(p,ensure_ascii=False))\nPY_REQUEST\ncurl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/chat/completions \\\n -H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \\\n --data-binary @request.json -D response-headers.txt -o result.json\npython3 - <<'PY_RESULT'\nimport json\nfrom pathlib import Path\nr=json.loads(Path("result.json").read_text())\nfor x in r.get("choices",[]):\n if x.get("message",{}).get("content"): print(x["message"]["content"])\nPY_RESULT\nfrom openai import OpenAI\nimport os\n\nif not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")\nclient=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)\nresult=client.chat.completions.create(model='moonshotai/kimi-k2.5',messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}])\nimport base64, json\nfrom pathlib import Path\n\ndef save_result(data, stem="result"):\n # Keep every field, including usage, IDs, reasoning and tool requests.\n Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")\n print(json.dumps(data, ensure_ascii=False, indent=2))\n def save_blob(encoded, suffix, label):\n raw = base64.b64decode(encoded, altchars=b"-_", validate=True)\n ext = "png" if raw.startswith(b"\\x89PNG\\r\\n\\x1a\\n") else "jpg" if raw.startswith(b"\\xff\\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix\n file = Path(stem + "-" + label + "." + ext)\n file.write_bytes(raw)\n print("Saved", file)\n for index, block in enumerate(data.get("content") or []):\n print("Content", index, json.dumps(block, ensure_ascii=False))\n for choice in data.get("choices") or []:\n print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))\n for index, item in enumerate(data.get("output") or []):\n print("Output", index, json.dumps(item, ensure_ascii=False))\n if item.get("type") == "image_generation_call" and item.get("result"):\n save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))\n for ci, candidate in enumerate(data.get("candidates") or []):\n for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):\n print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))\n blob = part.get("inlineData") or part.get("inline_data")\n if blob and blob.get("data"):\n mime = blob.get("mimeType") or blob.get("mime_type")\n suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")\n save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))\n\nsave_result(result.to_dict(mode="json"))\nfrom openai import OpenAI\nimport os\nfrom pathlib import Path\n\nif not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")\nclient=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)\nimport base64, json\nfrom pathlib import Path\n\ndef save_result(data, stem="result"):\n # Keep every field, including usage, IDs, reasoning and tool requests.\n Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")\n print(json.dumps(data, ensure_ascii=False, indent=2))\n def save_blob(encoded, suffix, label):\n raw = base64.b64decode(encoded, altchars=b"-_", validate=True)\n ext = "png" if raw.startswith(b"\\x89PNG\\r\\n\\x1a\\n") else "jpg" if raw.startswith(b"\\xff\\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix\n file = Path(stem + "-" + label + "." + ext)\n file.write_bytes(raw)\n print("Saved", file)\n for index, block in enumerate(data.get("content") or []):\n print("Content", index, json.dumps(block, ensure_ascii=False))\n for choice in data.get("choices") or []:\n print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))\n for index, item in enumerate(data.get("output") or []):\n print("Output", index, json.dumps(item, ensure_ascii=False))\n if item.get("type") == "image_generation_call" and item.get("result"):\n save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))\n for ci, candidate in enumerate(data.get("candidates") or []):\n for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):\n print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))\n blob = part.get("inlineData") or part.get("inline_data")\n if blob and blob.get("data"):\n mime = blob.get("mimeType") or blob.get("mime_type")\n suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")\n save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))\n\nwith client.chat.completions.stream(model='moonshotai/kimi-k2.5',messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}]) as stream:\n with Path("stream-events.jsonl").open("w",encoding="utf-8") as log:\n for event in stream:\n payload=event.to_dict(mode="json")\n log.write(json.dumps(payload,ensure_ascii=False)+"\\n"); log.flush()\n print(json.dumps(payload,ensure_ascii=False))\n final=stream.get_final_completion()\n save_result(final.to_dict(mode="json"),"stream-result")\njson or SSE
Keep every complete returned response, file and content part.
Keep every choice and its content/tool calls/reasoning. In SSE assemble deltas by choice/tool index, retain the final finish reason and usage.
Keep request/response IDs and headers. No generic text job retrieval URL is supplied.
| Field | Type |
|---|---|
Fieldchoices[].index | Typeinteger |
Fieldchoices[].message.content | Typestring|null |
Fieldchoices[].message.tool_calls | Typetool_call[] |
Fieldchoices[].message.reasoning_content | Typestring |
Fieldchoices[].message.reasoning_details | Typeobject|array |
Fieldchoices[].finish_reason | Typestring|null |
Fieldusage | Typeobject |
| Response | Condition | Next step |
|---|---|---|
Response400 · invalid_request_error | ConditionInvalid required fields, material representation or parameter value | Next stepCorrect the indicated fields before a new creation request. |
Ailoot Ultra moonshotai/kimi-k2.5
Use the method paths shown above.
moonshotai/kimi-k2.5Kimi K2.5 is Moonshot AI’s native multimodal agent model for image-grounded coding, reasoning and tool-assisted work. It combines text, images and video with thinking and instant modes, a 256K context and a producer workflow for coordinated agent subtasks.
This description covers the model’s capabilities. Available in Ailoot inputs, outputs and options are listed for the selected method below.
Kimi K2.5 is Moonshot AI’s native multimodal agent model, built by continued pretraining on approximately fifteen trillion mixed visual and text tokens over Kimi K2 Base. It combines language and vision with conversational and agent workflows. The input may contain text, images and video; the output is text such as an explanation, code or proposed tool operation.
The maker summary lists a mixture-of-experts architecture with one trillion total parameters and 32 billion activated parameters, a 256K context and a 400-million-parameter MoonViT visual encoder. K2.5 adopts the native INT4 quantization method documented for K2 Thinking. These are properties of the published producer checkpoint, distinct from an assertion about every surrounding execution configuration.
A defining use case is code generation from visual specifications, including interface designs and video workflows. Supply readable media, relevant source code and the intended behaviour. Identify which visual details are mandatory and how the result should respond to user interaction. A useful brief is: “Implement the supplied layout, preserve these labels and explain how the visible states correspond to the requirements.”
For an image-analysis task, ask for the visible detail supporting each finding and separate extraction from interpretation. For video, state the segment and the action or change to explain. The producer marks its demonstrated video workflow as experimental; understanding the media produces a textual result rather than rendering a new video or executing a visual action by itself.
K2.5 supports thinking and instant modes. Thinking develops reasoning before a final response; instant mode answers directly. The manufacturer’s reference deployment recommends temperature 1.0 for thinking, 0.6 for instant and top-p 0.95. Set the desired answer form separately from that reasoning choice, such as an extracted record, a decision memo or a complete code artifact.
For a difficult question, provide the full condition and relevant sources. A document brief can request a comparison with the supporting passage beside each conclusion. A coding brief can identify the failing input, constraints and change to propose. The output should remain traceable to that task rather than treating a long reasoning trace as a completed result.
K2.5 uses the same interleaved thinking and multi-step tool-call design as K2 Thinking. The application supplies functions with descriptions and schemas, executes selected operations and returns observations. Keep the results associated with their calls so the next step can use actual evidence.
The producer also describes an agent-swarm workflow that decomposes a complex goal into coordinated domain-specific subtasks. Prepare such a goal with defined outputs, allowed actions and criteria for completion. The final artifact should integrate the observations that were actually obtained; a generated plan or a proposed branch is distinct from executed work.
Budget the source, media representation, history, reasoning and final answer within the documented 256K context. The example request and evaluation token budgets in the card are not independently established universal output caps. Label sources and media so a result can refer back to its evidence.
The useful deliverable is an image-grounded explanation, code proposal or source-backed analytical result. Review values against the inputs and inspect code in its intended application. K2.5 remains its own multimodal release; later K2.6 preserve-thinking controls and earlier text-only K2 prompting profiles should not be substituted for this edition’s documented workflow.
POST /v1/messagestextjson, sse| Field | Type | Requirement | Values & limits | Default |
|---|---|---|---|---|
Fieldmodel | Typestring | RequirementRequired | Values & limits moonshotai/kimi-k2.5 | Default— |
Fieldmessages | Typemessage[] | RequirementRequired | Values & limits | Default— |
Fieldmessages[].role | Typestring | RequirementRequired | Values & limits user, assistant | Default— |
Fieldmessages[].content | Typestring | RequirementRequired | Values & limits | Default— |
Fieldmax_tokens | Typeinteger | RequirementRequired | Values & limits | Default— |
Fieldstream | Typeboolean | RequirementOptional | Values & limits | Defaultfalse |
Text · UTF-8 text
messages[].content string
| Parameter | Contract |
|---|---|
Parametercontent_type | Contractapplication/json |
Parameterrequired | Contractmodel, messages, max_tokens |
Parameteroptional_controls | Contractstream |
Parametermaterial_types | Contracttext |
Parametertext_file_material | ContractRead the actual UTF-8 document and put its text in the indicated input or message content string. |
Lifecycle: synchronous_or_streamed
Tariff references do not add request options. Supported parameters are listed for the selected method.
Match each charge to the conditions shown. Use one rate for each set of alternative configurations.
| Configuration | Rate schedule | Context tokens, more than | Context tokens, up to and including | Charge |
|---|---|---|---|---|
| ConfigurationBase token rates | Rate scheduleBase rate | Context tokens, more than— | Context tokens, up to and includingNo upper bound | Charge Input · Input tokens $0.0012 / 1K tokens Output · Output tokens $0.006 / 1K tokens Input · Cache read $0.0003 / 1K tokens Input · Cache write $0 / 1K tokens Input · Cache write, 1 hour — / 1K tokens |
| ConfigurationRequest-length tier 1 | Rate schedule— | Context tokens, more than0 | Context tokens, up to and includingNo upper bound | Charge Input · Input tokens $0.0012 / 1K tokens Output · Output tokens $0.006 / 1K tokens Input · Cache read $0.0003 / 1K tokens Input · Cache write $0 / 1K tokens Input · Cache write, 1 hour — / 1K tokens |
Ailoot reserves an estimated amount before a request. After the result, it settles the final charge from measured usage. Streaming settlement uses the final usage record. How reservation and settlement work →
{\n "model": "moonshotai/kimi-k2.5",\n "max_tokens": 128,\n "messages": [\n {\n "role": "user",\n "content": "Summarize the incident report."\n }\n ],\n "stream": false\n}set -eu\n: "${AILOOT_API_KEY:?Set your Ailoot API key}"\n: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 document}"\nexport AILOOT_TEXT_FILE\npython3 - <<'PY_REQUEST'\nimport json, os\nfrom pathlib import Path\n\nsource_file = Path(os.environ['AILOOT_TEXT_FILE'])\nif not source_file.is_file():\n raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')\ntext = source_file.read_text(encoding='utf-8')\nif not text.strip():\n raise SystemExit('Choose a document containing text')\npayload = {'model': 'moonshotai/kimi-k2.5', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}\npayload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\\n\\n' + text\nPath('request.json').write_text(json.dumps(payload, ensure_ascii=False), encoding='utf-8')\nPY_REQUEST\ncurl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/messages \\\n -H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -H 'Content-Type: application/json' \\\n --data-binary @request.json -D response-headers.txt -o result.json\npython3 - <<'PY_RESULT'\nimport json\nfrom pathlib import Path\n\nresult = json.loads(Path('result.json').read_text(encoding='utf-8'))\nprint(json.dumps(result, ensure_ascii=False, indent=2))\nPY_RESULT\nimport json, os\nfrom pathlib import Path\n\nsource_file = Path(os.environ['AILOOT_TEXT_FILE'])\nif not source_file.is_file():\n raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')\ntext = source_file.read_text(encoding='utf-8')\nif not text.strip():\n raise SystemExit('Choose a document containing text')\npayload = {'model': 'moonshotai/kimi-k2.5', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}\npayload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\\n\\n' + text\nfrom urllib.request import Request, urlopen\nfrom urllib.error import HTTPError\n\napi_key = os.environ['AILOOT_API_KEY']\nif not api_key.strip():\n raise SystemExit('Set AILOOT_API_KEY before making a request')\nheaders = {'x-api-key': 'PLACEHOLDER_KEY', 'anthropic-version': '2023-06-01', 'Content-Type': 'application/json'}\nheaders['x-api-key'] = api_key\nrequest = Request('https://api.ailoot.ai/v1/messages', data=json.dumps(payload, ensure_ascii=False).encode('utf-8'), headers=headers, method='POST')\ntry:\n with urlopen(request, timeout=120) as response:\n raw = response.read()\n Path('response-headers.txt').write_text(str(response.headers), encoding='utf-8')\nexcept HTTPError as error:\n Path('result.json').write_bytes(error.read())\n Path('response-headers.txt').write_text(str(error.headers), encoding='utf-8')\n raise\nPath('result.json').write_bytes(raw)\nimport json\nfrom pathlib import Path\n\nresult = json.loads(Path('result.json').read_text(encoding='utf-8'))\nprint(json.dumps(result, ensure_ascii=False, indent=2))\nJSON or SSE
Keep every complete returned response, file and content part.
Keep all content blocks, thinking signatures and actual tool-use IDs. Assemble all SSE block deltas; a first text block is not the complete output.
Keep request/response IDs and headers. No generic text job retrieval URL is supplied.
| Field | Type |
|---|---|
Fieldid | Typestring |
Fieldmodel | Typestring |
Fieldcontent[] | Typetext|thinking|tool_use|other content block |
Fieldstop_reason | Typestring|null |
Fieldusage | Typeobject |
| Response | Condition | Next step |
|---|---|---|
Response400 · invalid_request_error | ConditionInvalid required fields, material representation or parameter value | Next stepCorrect the indicated fields before a new creation request. |
Ailoot Ultra moonshotai/kimi-k2.5
Use the method paths shown above.
Technical example in English
Draft an accessible tab interaction\n\nProvide HTML and JavaScript for three text-only tabs: Overview, Details and Returns. Exactly one panel is visible. Mouse clicks and Left/Right arrow keys change tabs; Home selects the first and End the last. Preserve those labels and include the key accessibility attributes. Return the bounded component and a short interaction-check list without claiming execution.A self-contained tab component proposal and checks for click, arrow, Home and End behavior.The selected tab, focus behavior and visible panel remain consistent after each supported interaction.