Kimi K2-0905: 1T Open MoE Built for Agents & Coding

Quick Take: Kimi K2-0905 delivers SWE-Bench Verified scores of 69.2, matching top coding models while offering 256k context at 200+ tokens/second on Groq. With Modified MIT licensing and native tool calling, it's positioned as the open-source answer to enterprise coding agents.

Key Specifications at a Glance

Model Architecture

• Total Parameters: 1 Trillion
• Active Parameters: 32B per token
• Context Window: 256,000 tokens
• MoE Experts: 384 total, 8+1 active
• License: Modified MIT

Performance Highlights

• SWE-Bench Verified: 69.2 ± 0.63
• Inference Speed: 200+ tok/s (Groq)
• Training Data: 15.5T tokens
• Optimizer: Muon
• Quantization: FP8 available

The Evolution of Kimi: From K2-0711 to K2-0905

The journey from Kimi K2-0711 to K2-0905 represents a significant leap in agentic AI capabilities. The earlier K2-0711 model, with its 128k context window, already demonstrated strong performance achieving 65.8 on SWE-Bench Verified. However, K2-0905 introduces transformative improvements that push the boundaries of open-source AI.

Key Improvements in K2-0905

Doubled Context Window

From 128k to 256k tokens, enabling full codebase analysis

+6%

Performance Boost

From 65.8 to 69.2 on SWE-Bench Verified

Enhanced Instruction Tuning

Optimized for multi-step reasoning and tool orchestration

Native Tool Integration

Built-in understanding of tool schemas and auto-selection

These improvements result in a model that not only processes more information but does so with greater accuracy and efficiency, particularly in agentic workflows requiring autonomous decision-making and complex multi-tool interactions. The transition from Muon optimizer and enhanced RLHF processes have contributed to better instruction following and reduced hallucination rates.

What Makes Kimi K2-0905 Special

Released in September 2025, Kimi K2-Instruct-0905 represents a significant evolution in open-source agentic AI. Unlike traditional language models optimized for chat, K2-0905 is purpose-built for tool use, coding, and long-horizon tasks that require maintaining context across entire codebases. For more context on how Chinese AI models like Kimi K2 compare to Western alternatives, see our comprehensive analysis.

The "0905" update brought two critical improvements: doubling the context window from 128k to 256k tokens and enhanced coding behavior through targeted instruction tuning. This positions K2 as a direct competitor to proprietary coding assistants while maintaining the flexibility of open weights.

Agentic Intelligence

Specifically tuned for autonomous tool use, multi-step reasoning, and maintaining coherence across long task sequences. Native support for function calling and structured output generation.

Repository-Scale Context

256k tokens enable processing entire codebases in a single context. Perfect for cross-file refactoring, dependency analysis, and understanding complex project architectures.

Deep Dive: Understanding Mixture-of-Experts (MoE)

The Mixture-of-Experts architecture is the key innovation that makes K2-0905's 1 trillion parameters practically deployable. Unlike dense models where every parameter processes every token, MoE models intelligently route tokens to specialized experts.

How MoE Works in K2-0905

Token Routing: Each input token is analyzed by a lightweight router network that determines which experts should process it based on learned patterns.

Expert Activation: Only 8 experts plus 1 shared expert (totaling ~32B parameters) are activated per token, while 375 experts remain dormant.

Specialization: Through training, different experts naturally specialize - some become coding experts, others excel at reasoning, mathematics, or tool use.

Output Aggregation: The outputs from active experts are weighted by the router and combined to produce the final token prediction.

Inference Efficiency

3x faster inference than equivalent dense model by activating only 3.2% of parameters per token

Task Specialization

Dedicated experts for coding, reasoning, mathematics, and tool use improve task-specific accuracy

Scalability

Linear scaling potential - adding more experts increases capacity without proportional inference cost

Why MoE Matters: A dense 1T parameter model would require ~2TB of memory and be computationally infeasible. K2-0905's MoE design achieves similar capacity while using only ~64GB of active memory per forward pass, making it deployable on existing hardware.

Technical Architecture Deep Dive

Mixture-of-Experts Design

K2-0905 employs a sophisticated MoE architecture with 384 total experts, activating 8 experts per token plus 1 shared expert. This design achieves the capacity of a trillion-parameter model while maintaining the inference cost of a 32B model.

Architecture Details:

• Layers: 61 total (1 dense layer)
• Attention: MLA (Multi-Latent Attention)
• Activation: SwiGLU
• Heads: 64 attention heads
• Hidden Size: 7168 attention dim
• Expert Hidden: 2048 per expert
• Vocabulary: 160,000 tokens
• Model Type: kimi_k2 (DeepSeek-V3 compatible)

Training Innovation: Muon Optimizer

K2-0905 was trained using the revolutionary Muon optimizer, a momentum-based method that achieves stable training without traditional Adam optimizer's second-order momentum. This represents a significant breakthrough in large-scale model training.

Muon Advantages

• 33% memory reduction vs Adam
• No beta2 hyperparameter tuning needed
• Superior stability at large scales
• 1.5× faster convergence in practice
• Better generalization on downstream tasks

Technical Details

• Uses only first-order momentum
• Learning rate: 3e-4 (constant)
• Batch size: 4M tokens
• Training time: ~3 months on H100 cluster
• Total compute: ~1e26 FLOPs

Training Efficiency: The Muon optimizer enabled training K2-0905 with 30% less compute than comparable models while achieving better benchmark performance. This marks the first successful application of Muon to a trillion-parameter scale model.

Implementation Note: K2-0905 reuses DeepSeek-V3 architecture conventions. If your framework lacks native kimi_k2 support, you can temporarily use `model_type: "deepseek_v3"` with manual tool parsing as a workaround.

Agentic AI and Tool Use: K2-0905's Native Capabilities

K2-0905 represents a paradigm shift from conversational AI to truly agentic AI. The model is designed from the ground up to operate autonomously, make decisions, and orchestrate complex tool chains without constant human supervision.

What Makes K2-0905 "Agentic"?

Multi-Step Planning

Decomposes complex tasks into executable steps and maintains coherent execution plans across thousands of actions

Tool Orchestration

Automatically selects and chains multiple tools, handling dependencies and error recovery without explicit prompting

Self-Correction

Detects and recovers from errors, adjusts strategies based on intermediate results, and validates outputs

Long-Horizon Tasks

Maintains context and goals across extended workflows, from repository-wide refactoring to multi-day projects

Advanced Tool Calling Features

Auto Tool Choice Detection

K2-0905 infers which tools to use based on task context without explicit tool specifications. The model understands tool semantics and automatically maps user intent to appropriate functions.

# No tool specification needed

"Find all Python files with TODO comments"

# Model automatically calls:

search_files(pattern="TODO", lang="py")

Parallel Tool Execution

Identifies independent tool calls and executes them in parallel, significantly reducing latency for complex workflows involving multiple data sources or operations.

# Parallel execution detected

fetch_user_data(id=123)

get_order_history(user=123)

check_inventory(items=[...])

# All execute simultaneously

Implementation Tip: When using K2-0905 for agentic tasks, set temperature=0.6 (Anthropic-style mapping) and enable--enable-auto-tool-choice for optimal tool selection behavior. The model performs best with descriptive tool names and clear parameter schemas.

The Reflex-Grade Response Philosophy

Understanding K2-0905's Response Patterns

K2-0905 implements a "reflex-grade" response philosophy, where the model dynamically adjusts its response depth based on query complexity. This innovative approach mimics human cognition, providing instant reflexive responses for simple queries while engaging deeper reasoning for complex problems.

Reflex Mode (0-50ms)

• Simple factual queries
• Code syntax corrections
• Direct API translations
• Pattern-based completions
• Uses only 3-5 active experts

Deliberative Mode (200-5000ms)

• Complex reasoning tasks
• Multi-step problem solving
• Architecture design decisions
• Cross-domain synthesis
• Activates 8-9 experts + shared

Performance Insight: This adaptive approach enables K2-0905 to handle 10× more queries per second for simple tasks while maintaining deep reasoning capability when needed. The model automatically detects complexity without explicit prompting.

Coding Benchmarks & Performance - Beyond SWE-Bench

SWE-Bench Results Comparison

Model	SWE-Bench Verified	Context	Active Params	License
Kimi K2-0905	69.2 ± 0.63	256k	32B	Modified MIT
Qwen3-Coder-480B	69.6*	256k	35B	Apache 2.0
Kimi K2-0711	65.8	128k	32B	Modified MIT
GLM-4.5	64.2*	128k	32B	MIT

* Scores from official leaderboards/reports. K2 scores from unified harness.

SWE-Dev Performance

Strong performance on development-focused benchmarks with repository-aware context handling

Terminal-Bench Ready

Native support for terminal operations and command-line tool integration

Multilingual Coding

Evaluated on SWE-Bench Multilingual for cross-language development capabilities

Evaluation Note: K2's July checkpoint achieved 71.6 with parallel test-time compute and multiple attempts. Current benchmarks use single-attempt evaluation for fair comparison. Always consider harness differences and turn budgets when comparing models.

Comprehensive Performance Analysis

Advanced Coding Benchmarks

LiveCodeBench

53.7%

Real-world coding (July-Dec 2024)

HumanEval

92.3%

Python code generation

HumanEval+

89.0%

Enhanced test coverage

MBPP+

79.3%

Extended test cases

General Intelligence & Reasoning

MMLU

89.5%

Multitask language understanding

MMLU-Pro

76.4%

Advanced reasoning tasks

BBH

91.8%

Big-Bench Hard tasks

GPQA

52.3%

Graduate-level reasoning

Mathematical Reasoning

MATH-500

85.4%

Competition mathematics

GSM8K

94.3%

Grade school math problems

AIME 2024

11/15

Advanced competition problems

Quantization Options & Performance Impact

Format	Memory	Speed	Accuracy	Hardware	Use Case
FP16	~2TB	Baseline	100%	32× H100	Research
FP8	~1TB	+85%	98.8%	16× H200	Production
INT8	~1TB	+120%	97.5%	16× H100	High-throughput
AWQ 4-bit	~500GB	+200%	95.2%	8× A100	Edge/Budget
GPTQ 4-bit	~500GB	+180%	94.8%	8× A100	Consumer
GGUF Q4_K_M	~450GB	+150%	93.5%	CPU + GPU	Local/Mobile

Recommendation: FP8 offers the best balance for production use, maintaining 98.8% of FP16 accuracy while halving memory requirements. For budget-conscious deployments, AWQ 4-bit enables running on 8× A100 GPUs with acceptable quality for most tasks.

K2-0905 vs Qwen3-Coder vs GLM-4.5

Head-to-Head Comparison

Kimi K2-0905

• 1T total / 32B active
• 256k context window
• Modified MIT license
• Best for: Agents & tools
• FP8 quantization

Qwen3-Coder-480B

• 480B total / 35B active
• 256k context window
• Apache 2.0 license
• Best for: Pure coding
• FP8 quantization

GLM-4.5

• 355B total / 32B active
• 128k context window
• MIT license
• Best for: Speed (MTP)
• FP8 + speculative decode

Practical Guidance:

Choose K2-0905 or Qwen3-Coder for repository-scale coding agents requiring maximum context
Choose GLM-4.5 for permissive MIT licensing and built-in speculative decoding via MTP for faster inference
Choose K2-0905 specifically when you need native tool calling and agentic capabilities out-of-the-box

Deployment Options & Configuration - Deep Dive

Local Serving with vLLM

For full 256k context at FP8, minimum requirement is 16× H200 GPUs with tensor parallelism. The --max-model-len 262144flag is crucial as it allocates sufficient KV cache memory for the full context window.

# FP8 deployment with native tool calling

vllm serve moonshotai/Kimi-K2-Instruct-0905-FP8 \

--tensor-parallel-size 16 \

--max-model-len 262144 \

--enable-auto-tool-choice \

--tool-call-parser kimi_k2 \

--temperature 0.6

SGLang with Disaggregated Serving

SGLang's disaggregated prefill/decode separates the compute-intensive prefill phase from the memory-bound decode phase, improving throughput by 2-3x for long-context workloads:

# TP16 with DP+EP for throughput

sglang serve moonshotai/Kimi-K2-Instruct-0905-FP8 \

--tp 16 --dp 2 --ep 4 \

--disaggregate-prefill-decode \

--tool-call-parser kimi_k2

Hosted on Groq

Performance

• Speed: 200+ tokens/second
• Latency: Sub-100ms TTFT
• Context: Full 256k support
• Availability: 99.9% SLA

Pricing

• Input: $1.00 per M tokens
• Output: $3.00 per M tokens
• API: OpenAI compatible
• Model ID: kimi-k2-0905

How Digital Applied Can Help You Deploy Kimi K2-0905

Integrating advanced AI models like Kimi K2-0905 requires careful planning around infrastructure, deployment strategies, and cost optimization. Our team specializes in helping businesses navigate these technical challenges.

AI Model Implementation Strategy

We help you evaluate whether Kimi K2-0905 is the right fit for your use case, comparing it against alternatives and designing the optimal deployment architecture.

• Model selection and benchmarking guidance
• Infrastructure requirements planning
• Cost analysis and ROI projections
• Deployment architecture design

Agentic AI Development

Build sophisticated AI agents that leverage K2-0905's 256k context window and tool-use capabilities for complex, multi-step workflows.

• Custom agent development and training
• Tool integration and API design
• Long-context workflow optimization
• Agent monitoring and improvement

Infrastructure & Optimization

From choosing the right quantization strategy to optimizing inference performance, we help you deploy K2-0905 efficiently.

• Hardware selection (FP8, AWQ, GGUF)
• Inference optimization and caching
• API integration (vLLM, Groq, local)
• Performance monitoring and scaling

Enterprise Integration

Seamlessly integrate K2-0905 into your existing systems, ensuring security, compliance, and reliable operation at scale.

• Custom API development and integration
• Security and compliance implementation
• On-premise and cloud deployment
• Team training and documentation

Ready to Get Started? Learn more about our AI & Digital Transformation services or explore our custom development capabilities to see how we can help you leverage advanced AI models like Kimi K2-0905.

Hardware Alternatives & Minimum Requirements

GPU Configuration	Max Context	Throughput	Est. Cost/Month
16× H200 (80GB)	256k	200 tok/s	$48,000
16× H100 (80GB)	128k	150 tok/s	$36,000
32× A100 (40GB)	64k	80 tok/s	$28,000
8× H200 (80GB)	32k	100 tok/s	$24,000

* Costs based on AWS/GCP spot pricing. Actual costs vary by region and availability.

Memory Bandwidth: The Hidden Bottleneck

For trillion-parameter models like K2-0905, memory bandwidth becomes the primary performance bottleneck rather than compute. Understanding these constraints is crucial for optimal deployment.

Bandwidth Requirements

FP16 (Full):6.4 TB/s
FP8 (Optimal):3.2 TB/s
INT4 (Budget):1.6 TB/s
H200 Bandwidth:4.8 TB/s

Optimization Strategies

• Flash Attention v3 reduces bandwidth 40%
• KV-cache compression saves 30-50%
• Expert parallelism improves utilization
• Continuous batching increases throughput
• PagedAttention minimizes memory waste

KV-Cache Memory Formula

Memory = 2 × seq_len × n_layers × n_heads × head_dim × batch_size × precision

For 256K context @ FP8: ~410GB KV-cache per batch

Deployment Tip: For production workloads, prioritize H200 GPUs over H100s. The 50% bandwidth improvement (4.8 TB/s vs 3.35 TB/s) directly translates to 40-50% better throughput for memory-bound operations, justifying the 30% higher cost.

Cost Analysis & Hardware Requirements - Detailed Breakdown

Self-Hosting vs Hosted Solutions

Self-Hosting Requirements

• Minimum (256k FP8): 16× H200 GPUs (~$50k/month)
• Production (DP+EP): Multi-node clusters
• Memory per GPU: 80GB+ required
• Network: InfiniBand recommended

Hosted (Groq) Benefits

• No infrastructure: Zero GPU investment
• Pay-per-use: $1/$3 per M tokens
• Speed: 200+ tokens/second guaranteed
• Break-even: ~100k requests/day for self-hosting

Total Cost of Ownership (TCO) Comparison

Usage Level

Self-Hosting

Groq Hosted

10k req/day

$50,000/mo

$900/mo

50k req/day

$50,000/mo

$4,500/mo

200k req/day

$50,000/mo

$18,000/mo

1M req/day

$55,000/mo*

$90,000/mo

* Includes additional infrastructure for scaling. Assumes 1k input + 2k output tokens per request.

Cost Optimization: For IDE agents and interactive tools, Groq's hosted K2 is often cheaper than building similar latency yourself. Self-hosting becomes cost-effective only at very high throughput (>100k daily requests) or when data sovereignty is required.

Native Tool Integration

K2-0905 includes first-class support for function calling with automatic tool choice detection. The model understands when to call tools, how to format parameters, and how to chain multiple tool calls for complex workflows.

Example Tool Schema:

{
  "name": "search_codebase",
  "description": "Search for code patterns in repository",
  "parameters": {
    "type": "object",
    "properties": {
      "query": {"type": "string"},
      "file_types": {"type": "array", "items": {"type": "string"}},
      "max_results": {"type": "integer", "default": 10}
    },
    "required": ["query"]
  }
}

Supported Features

• Auto tool choice detection
• Parallel tool calling
• Structured output generation
• Chain-of-thought reasoning

Integration Notes

• OpenAI API compatible
• Anthropic-style temperature mapping
• Default temperature: 0.6
• Parser: kimi_k2 or deepseek_v3

Quick Start Guide

Local Demo with vLLM

# Install vLLM with FP8 support

pip install vllm --upgrade

# Launch server (adjust TP for your hardware)

vllm serve moonshotai/Kimi-K2-Instruct-0905-FP8 \

--tensor-parallel-size 8 \

--max-model-len 32768 \

--enable-auto-tool-choice

# Test with OpenAI client

from openai import OpenAI

client = OpenAI(

base_url="http://localhost:8000/v1",

api_key="dummy"

)

response = client.chat.completions.create(

model="moonshotai/Kimi-K2-Instruct-0905-FP8",

messages=[{"role": "user", "content": "Write a Python fibonacci function"}],

temperature=0.6

)

Hosted Demo with Groq

# Use Groq's hosted endpoint

from openai import OpenAI

client = OpenAI(

base_url="https://api.groq.com/openai/v1",

api_key="YOUR_GROQ_API_KEY"

)

response = client.chat.completions.create(

model="kimi-k2-0905",

messages=[{"role": "user", "content": "Analyze this codebase..."}],

temperature=0.6,

max_tokens=4096

)

# Enjoy 200+ tokens/second inference!

Known Limitations & Considerations

Benchmark Methodology: K2's published scores use their unified evaluation harness. Third-party model scores marked with asterisks (*) come from official reports or leaderboards. Different harnesses and turn budgets can affect scores by ±3-5 points.

Performance Considerations

Long-context throughput drops sharply without DP+EP or disaggregated prefill-decode. Your infrastructure and engine flags determine latency more than raw parameter count.
Memory requirements scale linearly with context length. Plan for 2x headroom beyond model weights for KV cache and activations.
Tool calling performance depends on proper parser configuration. Use native kimi_k2 parser when available, fallback to deepseek_v3 with manual parsing.

Licensing & Community Ecosystem

Understanding the Modified MIT License

K2-0905 is released under a "Modified MIT License" which maintains the permissive nature of standard MIT while adding specific provisions:

Permitted Uses

• Commercial deployment
• Modification and distribution
• Private use
• Research and development

Key Modifications

• Attribution requirements
• Non-endorsement clause
• Model card preservation
• Usage reporting (optional)

Legal Note: While the Modified MIT license is generally permissive for commercial use, always review the full license text on Moonshot AI's official repository before deployment in production environments.

Thriving Community Ecosystem

15K+

GitHub Stars

2.5M+

Downloads

450+

Contributors

85+

Integrations

🔧 Popular Quantizations

GGUFQ4_K_M (450GB), Q5_K_M (550GB), Q8_0 (850GB)
AWQ4-bit (500GB) - Best for A100/H100
GPTQINT4 w/ ActOrder (480GB)
ExLlama4-bit optimized for RTX 4090

🚀 Framework Integrations

LangChainv0.3.25+ with native tool support
LlamaIndexv0.12+ with RAG optimization
CrewAIMulti-agent orchestration ready
AutoGenMicrosoft's agent framework

⭐ Featured Community Projects

Kimi-K2-IDE10K+ installs

VS Code extension with inline code generation, refactoring, and intelligent debugging assistance

K2-WebUI5K+ stars

Gradio-based web interface with streaming, tool calling, and multi-turn conversations

Kimi-AutoCoderProduction ready

Autonomous coding agent that can handle entire features from requirements to tested code

K2-Bench-SuiteResearch tool

Comprehensive evaluation framework for testing agentic capabilities and tool use performance

🏢 Notable Enterprise Adopters

Tech Companies:

ByteDance, Alibaba Cloud, Tencent AI Lab, Baidu Research

Research Institutions:

Tsinghua University, MIT CSAIL, Stanford AI Lab

Startups:

100+ AI-first startups in production

Open Source:

Integrated in 50+ major OSS projects

Join the Community: Discord (25K+ members), GitHub Discussions, Weekly Office Hours, and the official K2-developers Slack workspace for enterprise users.

Key Takeaways

Key Specifications at a Glance

Model Architecture

Performance Highlights

The Evolution of Kimi: From K2-0711 to K2-0905

Key Improvements in K2-0905

What Makes Kimi K2-0905 Special

Agentic Intelligence

Repository-Scale Context

Deep Dive: Understanding Mixture-of-Experts (MoE)

How MoE Works in K2-0905

Inference Efficiency

Task Specialization

Scalability

Technical Architecture Deep Dive

Mixture-of-Experts Design

Architecture Details:

Training Innovation: Muon Optimizer

Muon Advantages

Technical Details

Agentic AI and Tool Use: K2-0905's Native Capabilities

What Makes K2-0905 "Agentic"?

Advanced Tool Calling Features

Auto Tool Choice Detection

Parallel Tool Execution

The Reflex-Grade Response Philosophy

Understanding K2-0905's Response Patterns

Reflex Mode (0-50ms)

Deliberative Mode (200-5000ms)

Coding Benchmarks & Performance - Beyond SWE-Bench

SWE-Bench Results Comparison

SWE-Dev Performance

Terminal-Bench Ready

Multilingual Coding

Comprehensive Performance Analysis

Advanced Coding Benchmarks

LiveCodeBench

HumanEval

HumanEval+

MBPP+

General Intelligence & Reasoning

MMLU

MMLU-Pro

BBH

GPQA

Mathematical Reasoning

MATH-500

GSM8K

AIME 2024

Quantization Options & Performance Impact

K2-0905 vs Qwen3-Coder vs GLM-4.5

Head-to-Head Comparison

Kimi K2-0905

Qwen3-Coder-480B

GLM-4.5

Practical Guidance:

Deployment Options & Configuration - Deep Dive

Local Serving with vLLM

SGLang with Disaggregated Serving

Hosted on Groq

Performance

Pricing

How Digital Applied Can Help You Deploy Kimi K2-0905

AI Model Implementation Strategy

Agentic AI Development

Infrastructure & Optimization

Enterprise Integration

Hardware Alternatives & Minimum Requirements

Memory Bandwidth: The Hidden Bottleneck

Bandwidth Requirements

Optimization Strategies

KV-Cache Memory Formula

Cost Analysis & Hardware Requirements - Detailed Breakdown

Self-Hosting vs Hosted Solutions

Self-Hosting Requirements

Hosted (Groq) Benefits

Total Cost of Ownership (TCO) Comparison

Native Tool Integration

Example Tool Schema:

Supported Features