MoonshotAI: Kimi K2 0905
Kimi K2 0905 is the September update of [Kimi K2 0711](moonshotai/kimi-k2). It is a large-scale Mixture-of-Experts (MoE) language model developed by Moonshot AI, featuring 1 trillion total parameters with 32...
Anyone in the Project can @-mention MoonshotAI: Kimi K2 0905 with the team's shared context - pooled credits, one chat, one memory.
Starter is free forever - 1 Project, 100 credits/month, 1 MCP. No card.
Verdict
Best for
- Long-context document analysis under budget
- Bilingual Chinese-English processing
- Multi-document synthesis and summarization
- Cost-sensitive extended reasoning tasks
Strengths
The 262K context window handles entire codebases, legal filings, or research paper collections in a single call. Input pricing at $0.60/Mtok undercuts GPT-4o ($2.50) and Claude Sonnet 4.5 ($3.00) by 75%, making it viable for high-volume long-context jobs. MoonshotAI optimized the model for Chinese-English bilingual tasks, a gap in many Western models. The architecture supports extended reasoning chains without the context-stuffing tricks required by smaller windows.
Trade-offs
Public benchmark coverage is sparse — no MMLU, HumanEval, or GPQA scores available to compare against Claude, GPT-4o, or Gemini on standard tasks. Output pricing at $2.50/Mtok sits near GPT-4o levels, so cost savings vanish if your use case generates verbose responses. Early reports suggest weaker performance on advanced math and code generation relative to Sonnet 4.5 or o1-preview. The model is less tested in production Western workflows than incumbents with years of public deployment.
Specifications
- Provider
- moonshotai
- Category
- llm
- Context length
- 262,144 tokens
- Max output
- 98,304 tokens
- Modalities
- text
- License
- proprietary
- Released
- 2025-09-04
Pricing
- Input
- $0.60/Mtok
- Output
- $2.50/Mtok
- Model ID
moonshotai/kimi-k2-0905
Per-token prices show what the model costs upstream. On Switchy your team draws from one shared org credit pool - one plan, one balance for everyone.
Team cost calculator
5 seats · 80 msgs/day
Switchy meters this against your org's shared credit pool - one plan, one balance for everyone.
Providers
| Provider | Context | Input | Output | P50 latency | Throughput | 30d uptime |
|---|---|---|---|---|---|---|
| moonshotai | 262k | $0.60/Mtok | $2.50/Mtok | — | — | — |
Performance
Benchmarks
Works well with
Top MCPs
Compatibility data comes from first-party telemetry; once we have enough co-usage signal, top MCPs for this model will appear here.
How Switchy teams use it
Starter prompts
Multi-Document Synthesis
I'm providing five research papers on climate adaptation strategies. Read all five, then produce a 500-word synthesis highlighting consensus findings, conflicting conclusions, and gaps in the literature.
Bilingual Contract Review
Compare the Chinese and English versions of this SaaS agreement. Flag any clauses where the translations diverge in meaning, especially around liability, termination, and IP rights.
Codebase Documentation
Here's a 50-file Python codebase for a task queue system. Write a 1000-word architecture overview covering data flow, key abstractions, and extension points for new developers.
Long-Form Q&A
I've pasted a 200-page employee handbook. Answer this question with specific section references: What are the procedures for requesting parental leave as a contractor in Germany?
Meeting Transcript Analysis
Here are transcripts from three consecutive board meetings (8 hours total). List all action items assigned to the CFO, grouped by strategic initiative, with timestamps.
Example outputs
Illustrative - representative of the model's voice and quality, not literal recordings.
Review this Python function for potential edge cases and suggest improvements. Focus on error handling and input validation.
The function lacks validation for empty inputs and doesn't handle None values, which could cause AttributeError exceptions. Consider adding type hints and guard clauses at the entry point. The nested loop has O(n²) complexity — if performance matters with large datasets, you could optimize using a set for O(n) lookups instead. Also, the current error messages don't specify which parameter failed validation, making debugging harder for API consumers. I'd recommend wrapping the core logic in try-except blocks and returning structured error objects rather than raising generic exceptions.
This example highlights Kimi K2's code review capabilities and attention to both correctness and performance trade-offs. The 262K token context window means it can analyze entire codebases in one pass, though without public benchmarks we can't compare its accuracy to models like Claude or GPT-4 on standard coding tasks.
Summarize this 80-page technical specification document and extract the five most critical implementation requirements for our engineering team.
The specification mandates: (1) End-to-end encryption using AES-256-GCM with key rotation every 90 days, (2) API response times under 200ms at p95 for all read operations, (3) PostgreSQL 14+ with row-level security policies enforced at the database layer, (4) Audit logging of all data access events retained for 7 years, and (5) Graceful degradation when third-party services are unavailable — the system must cache the last known good state. The document also discusses optional features like real-time notifications, but these five requirements are marked as blockers for the initial release and appear in the compliance checklist on page 67.
This showcases Kimi K2's long-context processing — 262K tokens handles roughly 200,000 words, enough for extensive documentation. The model extracts actionable requirements and cites page numbers, which is valuable for enterprise workflows. However, at $2.50/Mtok output, summarizing very long documents costs more than models like Gemini 1.5 Flash.
I'm preparing a presentation for non-technical stakeholders about our migration to microservices. Explain the benefits in business terms, avoiding jargon.
Moving to microservices means your engineering team can ship new features faster because different teams can work on separate parts of the system simultaneously without stepping on each other's toes. If one component fails — say, the recommendation engine — the rest of your application keeps running, so customers can still browse and purchase. You'll also save money long-term because you can scale only the parts of the system that need it, rather than duplicating the entire application. The trade-off is higher upfront complexity: your team will need to manage more moving parts and invest in monitoring tools. Most companies see ROI within 12-18 months if they're shipping features weekly.
This demonstrates Kimi K2's ability to translate technical concepts for business audiences while maintaining accuracy. The model balances benefits with honest trade-offs rather than overselling. The relatively low input cost ($0.60/Mtok) makes it economical for internal knowledge work compared to premium models, though we lack benchmark data to assess its reasoning depth against competitors.
Use-case deep-dives
When ultra-long context replaces analyst prep for exec teams
A 4-person executive team needs to distill 150 pages of market research, competitor filings, and internal metrics into a 20-slide board deck every quarter. Kimi K2 0905 ingests the full corpus in one pass—262K tokens covers roughly 800 pages of dense text—so the model can surface cross-document patterns a human analyst would take days to find. At $0.60 input per million tokens, a 200K-token research load costs $0.12, and the $2.50 output rate adds $0.05 for a 20,000-token draft deck. Total per-deck cost under $0.20 makes this viable for low-frequency, high-stakes synthesis. If you're running this weekly instead of quarterly, the output cost stacks up fast—switch to a model with cheaper generation. For rare, context-intensive executive work, Kimi's window is the unlock.
Frequently asked
Is Kimi K2 0905 good for long document analysis?
Yes. With a 262,144-token context window, Kimi K2 handles full-length books, legal contracts, and multi-file codebases in a single prompt. That's roughly 200,000 words of input — enough for most enterprise document workflows without chunking or summarization tricks.
Is Kimi K2 cheaper than GPT-4o for high-volume tasks?
Yes, significantly. At $0.60 input and $2.50 output per million tokens, Kimi K2 costs about 70% less than GPT-4o ($5 input / $15 output). For batch processing or long-context retrieval where you're reading more than writing, the savings compound fast.
Can Kimi K2 handle code generation and debugging?
Likely yes, but we lack public benchmarks to confirm quality against HumanEval or MBPP. MoonshotAI models historically perform well on Chinese-language tasks. If your codebase includes Chinese comments or documentation, test it. Otherwise, Claude or GPT-4o have proven track records.
How does Kimi K2 compare to the previous Kimi models?
We don't have benchmark data for earlier Kimi versions or this 0905 release, so direct comparison is speculative. The context window matches Kimi's known strength in long-form processing. Pricing stayed competitive. Without MMLU or MT-Bench scores, judge it by your own eval tasks.
Should I use Kimi K2 for real-time chat applications?
Depends on latency tolerance. MoonshotAI doesn't publish time-to-first-token numbers. The massive context window suggests the model is optimized for throughput over speed. For sub-second chat responses, test it first. For research or document Q&A where 2-5 second waits are acceptable, it's fine.
Compare with
More language models
- MoonshotAI: Kimi K2.5moonshotai
- MoonshotAI: Kimi K2.6moonshotai
- MoonshotAI: Kimi K2.7 Codemoonshotai
- MoonshotAI: Kimi K2 Thinkingmoonshotai
- MoonshotAI: Kimi K3moonshotai
- MoonshotAI: Kimi K3 (batch)moonshotai
- MoonshotAI: Kimi Latestmoonshotai
- Morph: Morph V3 Fastmorph
- Morph: Morph V3 Largemorph
- MythoMax 13Bgryphe
- Nex AGI: Nex-N2.5-Mininex-agi
- Nex AGI: Nex-N2.5-Pronex-agi