Kimi K3 Explained 2026 - Features, Benchmarks, API Pricing and Honest Limits

If you are searching kimi k3 explained, you want one page that separates launch theater from Monday decisions: what K3 is, what the benchmarks actually prove, how the API and pricing work, and when GPT-5.5 still wins.

Kimi K3 arrived on July 16, 2026 with numbers designed to stop a technical reader mid-scroll: 2.8 trillion total parameters, a 1-million-token context window, native visual understanding, always-on reasoning, and an API that costs $3 per million uncached input tokens and $15 per million output tokens (official Kimi K3 tech blog; Kimi K3 API quickstart). Moonshot also promised full model weights by July 27, 2026. Independent testing placed K3 among the leading frontier systems on Artificial Analysis’s Intelligence Index.

That makes K3 important. It does not make every launch claim equally proven.

This guide is for beginners choosing a first serious model, developers building coding or research agents, creators comparing app tiers and API spend, and companies deciding whether K3 deserves a controlled evaluation. You get a plain-language verdict, source-labeled benchmarks, normalized cost examples, working Python and cURL calls, a GPT-5.5 decision matrix, and a procurement checklist.

Time needed: 12 minutes to read the verdict; about 30 minutes to run the API quick start; one to two working days for a meaningful evaluation on your own tasks.

Facts checked July 26, 2026: Kimi K3 is live on Kimi.com, Kimi Work, Kimi Code, mobile apps, and the hosted API (kimi-k3). Official docs now support reasoning_effort values low, high, and max (default max). Full weights and the deeper technical report are still scheduled for July 27 — as of this refresh they are not yet publicly downloadable, and Artificial Analysis still labels the model proprietary. Treat “open” as a scheduled release until the checkpoint, license, and serving notes are live. API access unlocks after a successful top-up (minimum $1).

If your immediate goal is building a small game with Kimi rather than choosing an API, start with How to Create a Game with Kimi AI. For a working-developer harness and use-case playbook (Code, API agents, AGENTS.md), see Kimi K3 for Developers 2026. For ChatGPT-first game workflows, see the ChatGPT 5.5 game-development guide. For broader tool vocabulary, see AI Tools for Game Development - Overview and Setup. This page owns the model-evaluation question: when should a team choose Kimi K3 instead of GPT-5.5?

Kimi K3 explained - quick verdict

Short answer: Kimi K3 is a credible frontier model with especially strong value for long-context coding, document work, visual iteration, and tool-using agents. It is cheaper than GPT-5.5 at standard API rates, particularly for requests above 272K tokens, and its automatic 90% cache discount can make repeated codebase prompts economical. Independent measurements support the claim that K3 belongs near the frontier.

It is not an automatic GPT-5.5 replacement.

K3 is more verbose and notably slower than many peers in its price class on Artificial Analysis’s latest snapshot. Thinking is always on, but you can now dial reasoning_effort to low, high, or max — use low for cheaper, faster drafts and keep max for hard agent loops. It remains unusually sensitive to incomplete reasoning history and to mid-session model switches. Hosted web search through Formula is still marked as being updated and not recommended for production. The promised weights and full technical report are not downloadable yet. GPT-5.5 still offers finer reasoning labels (none through xhigh), a broader first-party tool surface, mature deployment choices, and a simpler path for teams already standardized on OpenAI's Responses API.

Our recommendation by buyer

Why Kimi K3 matters now

This is not an evergreen model card wearing a 2026 date. Four things still matter in the last ten days of July 2026.

First, Moonshot released K3 into Kimi.com, Kimi Work, Kimi Code, mobile apps, and the Kimi API. Developers can call kimi-k3 today rather than joining a waitlist. The official Kimi K3 launch post frames it as a long-horizon model for coding, knowledge work, and multimodal reasoning. Flagship API access unlocks after a successful top-up (minimum $1); cumulative top-ups also set rate-limit tiers.

Second, independent evidence is live and has moved since launch week. Artificial Analysis still scores K3 at 57 on its Intelligence Index (well above the price-class median), but as of this refresh the displayed class rank is about #7 / 190, output speed is about 33 tokens per second (notably slow vs a ~76 median), and verbosity remains extreme at ~130M evaluation output tokens. That does not validate every Moonshot benchmark, but it gives buyers a neutral anchor beyond a launch chart: intelligent, verbose, and slow.

Third, product surfaces moved past day-one defaults. Official API docs now document low / high / max reasoning effort. Kimi Code What’s New notes Moderato+ membership for K3 chat access and Allegretto+ for the full 1M window on that surface, plus CLI updates through late July (custom Markdown agents, tool toggles, cache warnings when switching models).

Fourth, the open-weight story is still incomplete. Moonshot calls K3 an open 3T-class model and says full weights will be released by July 27. Until the checkpoint, license, technical report, serving stack, and reproducible deployment instructions actually land, teams cannot responsibly budget a self-hosted production rollout. The hosted model is real; the open-weight operating plan is still a promise.

Demand is not hypothetical. A July 18 snapshot reported roughly 1.89 million views and 11,500 likes on Kimi's launch post. Semrush estimated 29.25 million visits to Kimi.com in June, before K3 launched, with organic search traffic up 59% month over month. Those figures prove attention, not product quality. They explain why a careful, updated explanation is useful now.

Kimi K3 features in plain language

2.8 trillion parameters does not mean 2.8 trillion active on every token

K3 uses a Mixture-of-Experts architecture. Moonshot says the model has 896 routed experts and activates 16 for a token through its Stable LatentMoE design. The 2.8T number describes total scale, not the compute used for every generated token.

This distinction matters because parameter-count comparisons can mislead. A sparse model can store broad capability while routing each token through a smaller slice of the network. Actual latency, memory, communication overhead, output quality, and cost are more decision-relevant than the largest number in the press release.

Moonshot recommends supernode deployments with 64 or more accelerators. Even after weights arrive, “open” will not mean “runs on an ordinary gaming PC.” Smaller community quantizations or distributed hosts may eventually appear, but this review does not assume they will preserve official quality.

Kimi Delta Attention and Attention Residuals

Moonshot identifies two central architecture changes:

• Kimi Delta Attention or KDA is a hybrid linear-attention mechanism intended to make very long sequences more efficient.
• Attention Residuals or AttnRes selectively retrieve representations across model depth instead of accumulating them uniformly.

The company says these changes, together with training and data improvements, provide roughly 2.5 times the scaling efficiency of Kimi K2. That is a vendor claim pending the promised technical report. Developers should care about the outcome—quality and speed over long sessions—not repeat an efficiency multiplier as if it were independently reproduced.

A 1M-token context window

The API documents a 1,048,576-token context limit. That can hold a large repository slice, hundreds of documents, or a long tool trace. K3 defaults to a maximum completion budget of 131,072 tokens and can be configured up to the full context limit, subject to the combined request constraints.

A large context window is capacity, not guaranteed recall. Your evaluation should include facts near the beginning, middle, and end of the prompt; conflicting instructions; tool logs; and questions that require joining evidence from distant sections. Retrieval, chunking, and context compaction can still beat “paste everything” on cost and reliability.

Native text, image, and video input

K3 accepts text and images, and the official quick start also documents uploaded video files. Public image URLs are not supported in the launch API; send image bytes as base64 or use an uploaded ms:// file reference.

For game teams, the practical attraction is a vision-in-the-loop workflow: provide code plus a screenshot of the broken scene, UI, level, or build output. For creators, it can inspect reference frames and source clips. Never mistake visual fluency for pixel-perfect verification. Keep deterministic image diffs, accessibility checks, performance captures, and human art direction in the pipeline.

Always-on reasoning with low / high / max effort

K3 always reasons — you cannot turn thinking off. The top-level API field is reasoning_effort. Official docs now support low, high, and max, with default max (Kimi K3 quickstart). Moonshot’s FAQ is blunt: if reasoning takes too long, set effort to low.

This has three consequences:

1. You still cannot disable reasoning for a pure classification or rewrite call.
2. Output and reasoning token use remain a meaningful part of the bill — especially at max.
3. You can now route easy prompts to low and hard agent loops to max without changing models.

GPT-5.5 remains more granular (none, low, medium, high, xhigh). If one application mixes trivial extraction with difficult planning, GPT-5.5’s none/low path may still beat K3 low on latency and waste. For K3 coding agents, start sessions on K3 (do not hot-swap from K2.6 mid-thread) and keep the complete assistant message — including thinking fields — between turns.

Tool calls, structured output, and dynamic tools

K3 supports tool calls, forced tool choice, JSON mode, strict JSON Schema, partial-mode continuation, and dynamically loaded tools. These are production features, not decorative benchmark capabilities.

Dynamic tools are useful when an agent has a huge catalog. The application can introduce the complete tool definition only when it becomes relevant, reducing the prompt footprint. Strict structured output helps turn a model response into validated game data, content metadata, QA findings, or a build triage object.

Do not grant a model every write-capable tool because its benchmark score is high. Separate read, propose, write, deploy, and delete permissions. Require human approval for destructive or external actions.

Automatic context caching

K3 automatically attempts to cache repeated prompt prefixes. There is no cache ID or extra parameter for ordinary model requests. Keep the large, stable prefix byte-for-byte unchanged and append changing questions after it.

Official pricing is:

• $0.30 per million cache-hit input tokens
• $3.00 per million uncached input tokens
• $15.00 per million output tokens, including reasoning

Moonshot says the official API sees a cache-hit rate above 90% in coding workloads. That is useful operational information but still a provider-reported aggregate. Measure your own hit rate; small changes to a repository snapshot, system prompt, or tool catalog can change the economics.

Kimi K3 benchmarks - what the numbers do and do not prove

Benchmarks are most useful when you know who ran them, which harness was used, what reasoning budget was allowed, and whether another lab reproduced the result.

Moonshot reports K3 at maximum reasoning with temperature 1.0 and top-p 1.0. Depending on the test, models used KimiCode, Claude Code, Codex, or another harness. That creates a real comparability limitation: an agent score measures the model plus tools, prompts, scaffolding, retries, and execution environment.

Selected vendor-reported benchmark results

The following values come from Moonshot's launch table and notes. They are directional, not a substitute for your workload.

The table looks decisive. The footnotes make it less simple.

• K3 often used KimiCode while GPT-5.5 used Codex.
• Some scores were adopted from public leaderboards; others were run by Moonshot.
• Kimi Code Bench is an internal benchmark.
• Hardware and harnesses differ on some tests.
• Maximum reasoning can use very different numbers of tokens across models.

The responsible conclusion is not “K3 beats GPT-5.5 at everything.” It is “K3 produced strong launch results across coding, agentic, and multimodal tasks, often above the GPT-5.5 comparison shown by Moonshot.”

Independent Kimi K3 results

Artificial Analysis provides the most useful neutral snapshot available at this refresh:

The verbosity figure is the warning most roundups miss. A model charging half as much per output token can lose part of that advantage if it emits twice as many tokens to solve the same task. Production telemetry should record input tokens, cache hits, reasoning tokens where available, answer tokens, latency, retries, and task success—not price per million alone.

Also note: independent speed and latency numbers drift as providers tune serving. Re-check Artificial Analysis’s Kimi K3 page before you lock a SLA based on an older screenshot.

A benchmark trust ladder

Use this order when making a decision:

1. Your blinded production-like tasks with a clear rubric and fixed budget.
2. Independent evaluations with published methodology.
3. Public leaderboards where harness and settings are comparable.
4. Vendor-run public benchmarks with detailed footnotes.
5. Vendor case studies that are impressive but difficult to reproduce.
6. Social screenshots and anecdotes with unknown prompts.

K3 clears levels two through five. Your company must still perform level one.

Kimi K3 vs GPT-5.5 feature comparison

Where Kimi K3 is stronger

• List price: standard output is half GPT-5.5's rate.
• Long-context economics: K3 keeps flat pricing while GPT-5.5 applies higher rates once input exceeds 272K.
• Video input: K3 documents an uploaded-video path.
• Current agentic benchmark story: launch and independent results make K3 a serious coding and knowledge-work candidate.
• Potential future deployment control: if Moonshot releases usable weights under acceptable terms, teams gain options unavailable with GPT-5.5.

Where GPT-5.5 is stronger

• Reasoning control: GPT-5.5 still offers none and more fine-grained budgets; K3 improved from max-only to low/high/max but cannot turn thinking off.
• First-party tool ecosystem: the model page lists web search, file search, code interpreter, hosted shell, apply patch, computer use, MCP, and tool search.
• Operational maturity: model snapshots, documented rate tiers, Batch, Flex, Priority, and regional processing give platform teams more explicit levers.
• Provider continuity: teams already using OpenAI authentication, observability, safety controls, and procurement can avoid another integration.
• Current status clarity: GPT-5.5 is proprietary and says so; K3's “open” value depends on a future artifact.

Kimi K3 pricing compared with GPT-5.5

Price pages quote dollars per million tokens, but applications buy completed tasks. Here are normalized examples using direct standard API rates and excluding taxes and tool-call fees.

Scenario 1 - A normal coding request

Assume 100,000 input tokens and 10,000 output tokens.

K3 costs 44% less in the uncached example. With cached input, it costs about 49% less. If K3 generates substantially more output to finish the same job, the real gap narrows.

Scenario 2 - A one-million-token repository request

Assume 1,000,000 input tokens and 100,000 output tokens. GPT-5.5's prompt exceeds 272K, so OpenAI says the entire session uses 2x input and 1.5x output rates.

This is K3's clearest price advantage. It is also an intentionally extreme request. Many teams will get better reliability and lower total cost by retrieving only relevant files rather than sending a million tokens every turn.

Scenario 3 - One million short production calls

Suppose each call averages 2,000 uncached input tokens and 300 output tokens. Across one million calls, that is 2 billion input and 300 million output tokens.

• Kimi K3: (2,000 × $3) + (300 × $15) = $10,500
• GPT-5.5: (2,000 × $5) + (300 × $30) = $19,000

That headline saving matters, but leaving every call on default max reasoning may be the wrong tool for a million simple calls. Prefer reasoning_effort="low" for extraction, or route those jobs to a cheaper small model, rules engine, local classifier, or cached template. Use frontier models for tasks that need frontier capability.

Cost controls teams should add

• Cap maximum completion tokens.
• Track cache-hit and cache-miss input separately.
• Route low-risk extraction to a smaller model.
• Stop tool loops after a defined number of steps.
• Require a budget estimate before long-context jobs.
• Cache deterministic tool results in your application.
• Measure accepted outputs per dollar, not generated tokens per dollar.
• Use retries only for transient failures and add exponential backoff.

Our free AI API resource is a useful map for prototypes, while the OpenAI API 429 help page explains the queue and retry discipline that applies to any model provider.

Kimi K3 API quick start

What you need

• Python 3.9 or newer
• A Kimi API account, key, and a successful top-up (minimum $1 unlocks flagship models)
• The openai Python package
• 10 minutes for a basic call
• A separate test project with no production secrets

Install the client:

python -m pip install --upgrade "openai>=1.0"

Store the key in an environment variable. Do not paste it into source control.

PowerShell:

$env:MOONSHOT_API_KEY="replace-with-your-key"

Bash:

export MOONSHOT_API_KEY="replace-with-your-key"

Python request

import os

from openai import OpenAI

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

response = client.chat.completions.create(
    model="kimi-k3",
    reasoning_effort="low",  # use "max" for hard agent / coding loops
    messages=[
        {
            "role": "user",
            "content": (
                "Review this feature proposal. Return three risks, "
                "three tests, and one ship or hold recommendation."
            ),
        }
    ],
)

print(response.choices[0].message.content)
print(response.usage)

Success check: the call returns a final answer and a usage object. Record the model ID, request time, token counts, and your own task result. Never log the API key or sensitive prompt body.

cURL request

curl https://api.moonshot.ai/v1/chat/completions \
  --header "Authorization: Bearer $MOONSHOT_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{
    "model": "kimi-k3",
    "reasoning_effort": "low",
    "messages": [
      {
        "role": "user",
        "content": "Explain this crash report and propose an ordered test plan."
      }
    ]
  }'

The multi-turn rule that can break K3

Moonshot's documentation says multi-turn conversations and tool calls must append the complete assistant message returned by the API. Do not keep only its visible content.

K3 was trained with preserved thinking history. Moonshot warns that omitting historical thinking content, or switching an existing session from another model to K3, can make generation quality highly unstable.

In practice:

messages = [{"role": "user", "content": "Inspect the task and propose a plan."}]

first = client.chat.completions.create(
    model="kimi-k3",
    messages=messages,
)

# Keep the complete message object, not only first.choices[0].message.content.
messages.append(first.choices[0].message)
messages.append(
    {
        "role": "user",
        "content": "Now identify the riskiest assumption in that plan.",
    }
)

second = client.chat.completions.create(
    model="kimi-k3",
    messages=messages,
)

If your framework serializes messages into a provider-neutral text-only format, test this behavior before adopting K3. A generic router that strips provider fields can silently degrade quality.

Streaming reasoning and final content

K3 streams reasoning_content separately from final content. Applications should not merge hidden reasoning into the user-facing answer or store it casually. Display the final answer, treat reasoning fields according to provider policy, and avoid exposing internal traces to end users.

Structured JSON output

For production extraction, use a strict schema instead of asking for “valid JSON” in prose:

import json

response = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {
            "role": "user",
            "content": "Classify the build as pass, hold, or fail and explain why.",
        }
    ],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "build_review",
            "strict": True,
            "schema": {
                "type": "object",
                "properties": {
                    "decision": {
                        "type": "string",
                        "enum": ["pass", "hold", "fail"],
                    },
                    "reason": {"type": "string"},
                },
                "required": ["decision", "reason"],
                "additionalProperties": False,
            },
        },
    },
)

result = json.loads(response.choices[0].message.content or "{}")
print(result)

A valid schema is not a truthful answer. Validate factual claims, enforce allowed actions, and keep deterministic release gates outside the model.

How to run a fair Kimi K3 vs GPT-5.5 test

Do not paste ten prompts into two chat windows and crown a winner. Build a small evaluation set before you see either model's answers.

Step 1 - Choose 20 to 50 real tasks

Include the work you actually pay people or systems to do:

• explain a real bug from logs and code
• edit a function without changing public behavior
• extract requirements from a long partner document
• compare screenshots against an acceptance checklist
• call tools in the right order
• produce strict JSON that passes validation
• refuse an unsafe or unauthorized action
• admit when supplied evidence is insufficient

Remove secrets and personal data. Keep the original difficulty and ambiguity.

Step 2 - Define the rubric first

Score each answer on:

• factual correctness
• task completion
• code or artifact validity
• instruction following
• unsupported claims
• tool-call correctness
• latency
• total token cost
• human edit time

Use hard pass/fail checks where possible. “Looks smart” is not a metric.

Step 3 - Match budgets and tools

Give both models the same source material, tool permissions, timeout, maximum steps, and output requirements. Matching reasoning labels is not enough because max and xhigh do not represent identical compute.

Run at least three repeats on nondeterministic tasks. Record failures, not only best outputs.

Step 4 - Blind the human review

Hide model names and shuffle outputs. Reviewers who know an answer came from the exciting new release can unconsciously reward it.

Step 5 - Calculate completed-task cost

Use:

completed_task_cost =
  total_api_cost
  + retry_cost
  + tool_cost
  + human_review_minutes × loaded_hourly_rate / 60

A model that costs $0.30 more but saves eight minutes of correction is cheaper. A model with a low token bill that silently corrupts structured data is expensive.

Security, privacy, and enterprise readiness

Moonshot says Kimi Enterprise provides enterprise-grade data privacy, member management, and separation between personal and organization accounts. That is a starting point for diligence, not a replacement for contract review.

Before sending source code, customer records, financial documents, unreleased art, or partner material, ask for written answers to:

1. Where is request and response data processed?
2. How long are prompts, files, tool results, and logs retained?
3. Are customer inputs or outputs used for training by default?
4. What deletion controls and audit logs exist?
5. Which subprocessors can access data?
6. Are regional processing or data-residency options available?
7. What certifications, incident-notification terms, and support SLAs apply?
8. Can the provider execute a data-processing agreement?
9. How are uploaded image and video files deleted?
10. What happens to cached prompt prefixes?

OpenAI is not automatically the safe answer. Its GPT-5.5 documentation notes a 10% uplift for regional processing, and your organization still needs the correct product terms, endpoint, retention configuration, access controls, and DPA.

Safe agent permissions

K3's launch post acknowledges excessive proactiveness: on ambiguous tasks, the model may make unexpected decisions on the user's behalf. That is a serious agent-design warning.

Use permission tiers:

System prompts help, but enforcement belongs in application code. A model cannot grant itself a tool it never receives.

Kimi K3 limitations and red flags

The weights are not available yet

The biggest caveat is temporal. Moonshot promises weights by July 27, but a promised release is not a downloadable checkpoint. Do not approve self-hosting architecture, hardware purchases, or license-dependent commercial plans until the real files and terms are reviewed.

Maximum reasoning is the default — not the only option

At launch, only max was documented. As of this July 26 refresh, official docs support low, high, and max. Simple tasks should not stay on default max unless you have measured that they need it. Route trivial extraction to low, a smaller model, or a non-LLM path.

K3 is sensitive to reasoning history

Dropping fields from the assistant message or switching models mid-session can destabilize output. Provider-neutral abstractions must preserve the full K3 conversation contract.

It can be too proactive

Explicitly constrain what the agent may change. Use dry-run modes, allowlists, approval gates, and reversible operations.

Web search is not production-ready

Kimi's own quick start says web search is being updated and is not recommended in the near term. Bring your own retrieval or wait for a documented stable release.

Independent testing finds high verbosity

Artificial Analysis recorded 130M output tokens across its Intelligence Index, compared with a displayed average of 63M. Watch accepted-answer cost and time, not only nominal token prices.

Vendor benchmarks remain vendor benchmarks

Moonshot publishes unusually useful footnotes, but many headline comparisons still combine different harnesses. Do not turn a launch table into a universal ranking.

Open-weight operation may be impractical for small teams

Moonshot recommends 64-plus-accelerator supernodes. Future quantizations and hosted providers may reduce the barrier, but the official-scale model is not a local-laptop replacement for the free local LLM tools in our dialogue guide.

Common Kimi K3 mistakes

1. Calling K3 open source today. Say the hosted model is live and weights are promised for July 27.
2. Comparing only price per token. Include verbosity, retries, tool costs, and human correction.
3. Keeping only visible assistant content. Preserve the complete assistant message in multi-turn sessions.
4. Switching an old session to K3. Start a clean K3 session unless compatibility is proven — model switches also invalidate prompt cache.
5. Setting unsupported sampling fields. K3 fixes temperature, top-p, n, presence penalty, and frequency penalty at documented values (omit them).
6. Using the old K2 thinking parameter. Use top-level reasoning_effort with low, high, or max.
7. Leaving every call on default max. Use low for drafts and cheap classification; reserve max for hard agent loops.
8. Expecting public image URLs to work. Send base64 or an uploaded file reference.
9. Trusting a 1M prompt without retrieval tests. Capacity does not guarantee recall or instruction priority.
10. Giving the agent broad write access. K3's own limitations warn about proactive behavior.
11. Using launch-day web search in production. The official docs recommend against it for now.
12. Assuming cache hits without a long enough prior prompt. Official caching notes require the previous request’s prompt tokens to exceed 256 before a prefix can be reused.

A two-day adoption plan

Day 1 - Capability and cost

• Create an isolated test key and project.
• Run five short tasks and five long-context tasks.
• Verify streaming, strict JSON, and one read-only tool.
• Test a multi-turn conversation while preserving full messages.
• Record latency, cache hits, input, output, and accepted results.
• Compare with GPT-5.5 under the same rubric.

Day 2 - Safety and operations

• Run prompt-injection and ambiguous-instruction tests.
• Confirm tool allowlists and approval boundaries.
• Trigger timeouts, rate limits, malformed JSON, and provider errors.
• Test fallback to a different model only at a clean session boundary.
• Document data classification and forbidden inputs.
• Set a daily budget and alert threshold.
• Produce a keep, pilot, or reject decision with evidence.

Do not wait for perfect certainty. A controlled pilot can begin now. Production self-hosting cannot.

Who should choose Kimi K3

Choose K3 now when:

• long-context cost is central to the workload
• coding, research, document, or visual agent tasks dominate
• your application can preserve provider-specific message fields
• you can tolerate launch-stage changes
• you will benchmark task success instead of trusting charts
• a future open-weight path has strategic value, but is not required today

Keep GPT-5.5 when:

• you need none / medium-grain reasoning budgets K3 cannot match
• your stack depends on OpenAI's hosted tools or Responses API
• procurement and observability are already approved
• model snapshot pinning matters immediately
• adding another provider costs more than the likely savings
• you need predictable handling of many simple and complex tasks in one platform

Use neither frontier model by default when:

• the task is deterministic
• a small model meets the quality bar
• sensitive data cannot leave your environment
• latency matters more than deep reasoning
• the unit economics fail at expected traffic

Key takeaways

• Kimi K3 is a real hosted frontier model released July 16, 2026, not a rumor.
• It combines a 2.8T sparse architecture, 1M-token context, native vision, tool use, and always-on reasoning.
• Official prices are $0.30 cached input, $3 uncached input, and $15 output per million tokens — flat across the 1M window.
• GPT-5.5 costs $5 input, $0.50 cached input, and $30 output below 272K, with higher long-context rates.
• Independent testing still scores K3 at 57 on the Intelligence Index; latest class rank and speed (~33 tok/s) show it is smart but slow and verbose.
• reasoning_effort now supports low / high / max (default max) — do not leave every call on max.
• K3's high output-token use can narrow its apparent price advantage.
• Moonshot's benchmark table is strong, but harness differences prevent a universal “K3 wins” conclusion.
• Preserve the complete assistant message across K3 turns; content-only history can destabilize quality.
• K3's open weights and full technical report are promised for July 27 and were not available when checked July 26.
• Small teams should not assume a 2.8T model will be practical to self-host.
• GPT-5.5 remains stronger for none-level reasoning, first-party tools, and established OpenAI operations.
• The correct winner is the model that completes your blinded tasks safely at the lowest total cost.

FAQ

Is Kimi K3 better than GPT-5.5?

Kimi K3 is better on list price and some published coding, automation, document, and multimodal benchmarks. Independent testing places it near GPT-5.5 overall. GPT-5.5 offers more reasoning controls (including none), broader first-party tools, and mature platform options. Test both on your own tasks before choosing.

How much does the Kimi K3 API cost?

Kimi K3 costs $3 per million uncached input tokens, $0.30 per million cache-hit input tokens, and $15 per million output tokens. Rates are flat across its 1M-token context window. Flagship API access unlocks after a successful top-up (minimum $1). Taxes and third-party provider pricing may differ.

Is Kimi K3 open source?

Not yet in the practical sense. The hosted model is live, but full weights were not publicly available when this article was checked on July 26, 2026. Moonshot says it will release them by July 27 with more technical details. Artificial Analysis still labels the model proprietary until weights land. Review the actual license and files after release.

What is the Kimi K3 context window?

The official API documents a 1,048,576-token context window. A large window lets K3 receive very long repositories and document collections, but it does not guarantee perfect recall. On Kimi Code product surfaces, Allegretto+ membership is documented for unlocking the full 1M window — confirm current tier rules before budgeting. Test retrieval quality and cost at your real prompt lengths.

Does Kimi K3 support images and video?

Yes. K3 supports text and image input, and its API quick start documents uploaded video input. Public image URLs are not supported; use base64 data or uploaded ms:// references. Make vision content an array of objects, not a serialized string.

Can I use Kimi K3 with the OpenAI Python SDK?

Yes. Install the OpenAI package, create an OpenAI client with https://api.moonshot.ai/v1 as the base URL, and call the kimi-k3 model. K3 uses Chat Completions-compatible requests with provider-specific reasoning_effort and message-history requirements.

What reasoning effort values does Kimi K3 support?

Always-on thinking with top-level reasoning_effort set to low, high, or max (default max). You cannot disable thinking entirely. Use low when responses feel too slow or expensive for the task.

What is Kimi K3 best for?

K3 is best suited to long-horizon coding, large-repository analysis, research, document work, multimodal reasoning, and tool-using agents. For simple classification or short formatting, prefer reasoning_effort="low" or a smaller model — default max can be excessive.

Should a company deploy Kimi K3 now?

Run a controlled hosted-API pilot now if K3 fits the workload. Do not approve self-hosting until the weights, license, technical report, hardware plan, and serving ecosystem exist and pass review. Complete privacy, retention, residency, security, support, and exit diligence before production.

Final assessment

Kimi K3's most important achievement is not a single benchmark win. It is that a new model can enter the frontier conversation with independent evidence, a million-token context, credible agent capabilities, and prices that pressure GPT-5.5—while still publishing enough limitations to make a sober decision possible.

The sober decision is conditional.

K3 is an excellent candidate for a measured pilot. It is particularly attractive when prompts are long, repeated prefixes cache well, and coding or knowledge-work agents can justify high or max reasoning. GPT-5.5 remains the safer operational choice for teams that need none-level effort, OpenAI's full tool platform, snapshot stability, and an already-approved vendor path.

Do not choose from a leaderboard screenshot. Take 20 real tasks, blind the outputs, count accepted results, price the retries and human edits, and verify permissions under failure. Then keep the model that wins your work—not the launch week.

Bookmark this page when benchmarks or hosted pricing move. Open weights are now live on Hugging Face moonshotai/Kimi-K3 — for self-host diligence (license, hardware honesty, API vs on-prem), follow How to Try Kimi K3 Open Weights - First Indie Self Host Spike 2026. That keep/hold does not replace this Explained URL for benchmarks and pricing.

For Kimi K3 in a current six-provider game-development decision, continue with Best AI Models for Game Development 2026 - ChatGPT, Claude, Gemini, Kimi, DeepSeek, and Qwen. That comparison adds GameCraft-Bench limits, current model IDs, engine routing, and cost-per-verified-pass scoring; this page remains the deeper Kimi explained guide.

If your goal is building a first playable with Kimi rather than comparing APIs, follow How to Create a Game with Kimi AI - Step by Step Beginner Guide 2026. For coding agents, AGENTS.md, and real use-case receipts, follow Kimi K3 for Developers 2026.

Sources

• Kimi K3 launch and benchmark notes
• Kimi K3 API quick start
• Kimi K3 API pricing
• Kimi Code What’s New (K3 product notes)
• Artificial Analysis Kimi K3 measurements
• OpenAI GPT-5.5 model documentation
• OpenAI API pricing

Found this useful? Share it with the person responsible for model cost, security, or agent quality—and ask them to bring a real evaluation set.