Try Kimi at kimi.com →

Kimi-Dev-72B
Moonshot's Open Bug-Fixing Model

Kimi-Dev is Moonshot AI's open-source coding model that learned to fix real GitHub issues, finding the bug, patching it and writing the test, by practising inside Docker until whole test suites passed. Here's how it works, what it scored and when it's still worth using.

60.4% SWE-bench Verified 72B, MIT licence June 2025
Issue #4182 Date parsing failsfor leap years bug BugFixersame 72B model 1 · Find fileutils/dates.py 2 · Edit - if year % 4:+ if not is_leap(year): TestWritersame 72B model 1 · Find filetests/test_dates.py 2 · Edit + def test_feb_29():+ parse('2024-02-29') DOCKERrun tests ✗ before patch ✓ after patch Issue resolved Example issue for illustration. Reward only when the whole test suite passes.
OVERVIEW

Kimi-Dev at a glance

60.4%SWE-bench Verified

Top open-model score when released, Moonshot-reported.

72BParameters

A dense model built on Qwen2.5-72B.

2 rolesBugFixer + TestWriter

One model that both fixes bugs and writes tests.

MITOpen licence

Weights, code and a peer-reviewed paper are public.

Status, November 2026: Kimi-Dev is a 2025 research model. Moonshot's current coding models in Kimi Code are much stronger. Kimi-Dev is still useful for research and self-hosting on smaller hardware.
SPECS

Kimi-Dev specifications

SpecKimi-Dev-72B
Released17 June 2025
DeveloperMoonshot AI (Kimi-Dev team)
ModelKimi-Dev-72B, a 72-billion-parameter dense model built on Qwen2.5-72B
PurposeResolving real software issues: finding the bug, patching it and writing tests
Headline result60.4% on SWE-bench Verified (Agentless setup, Moonshot-reported)
TrainingAbout 150B tokens of mid-training on real code data, then reinforcement learning in Docker
LicenceMIT
WhereGitHub (MoonshotAI/Kimi-Dev) and Hugging Face (moonshotai/Kimi-Dev-72B)
Paper“Kimi-Dev: Agentless Training as Skill Prior for SWE-Agents”, ICLR 2026
Hosted APINone. Run it yourself.

From Moonshot's Kimi-Dev GitHub repository, blog post and paper.

HOW

How Kimi-Dev was trained

  1. 1

    Mid-training

    About 150B tokens of real-world GitHub issues, pull requests and commits taught the model how developers fix bugs. Moonshot removed any repository used in SWE-bench Verified.

  2. 2

    Cold start

    Worked examples of locating files and editing code gave it a starting point for both roles.

  3. 3

    Reinforcement learning

    The model patched real repositories inside Docker and was rewarded only when the whole test suite passed, so partial fixes earned nothing.

  4. 4

    Test-time self-play

    At answer time it writes several patches and several tests, runs them against each other and submits the patch that passes the most.

TEST-TIME SELF-PLAYEvery candidate patch is run against every candidate test T1 T2 T3 T4 T5 Patch A ✓ ✗ ✓ ✗ ✓ 3/5 Patch B ✓ ✓ ✓ ✓ ✓ 5/5 Patch C ✗ ✗ ✓ ✗ ✗ 1/5 Patch D ✓ ✓ ✗ ✓ ✓ 4/5 Patch B passes the most tests, so it is submitted BugFixer writes the patches, TestWriter writes the tests. Simplified illustration of the method in Moonshot’s paper.

Self-play: patches and tests check each other, and the best patch wins.

RESULTS

Kimi-Dev results

TestKimi-Dev-72BWhat it means
SWE-bench Verified, Agentless60.4%Best among workflow approaches and open models when released (June 2025)
SWE-bench Verified, as an agent48.6% pass@1After light fine-tuning on 5k public agent runs; on par with Claude 3.5 Sonnet (Oct 2024)
SWE-bench-Live and MultilingualGains carried overPaper shows its skills generalise beyond the benchmark it trained for

Moonshot-reported, from the Kimi-Dev blog and paper. Moonshot said Kimi-Dev beat the much larger DeepSeek-R1 update of May 2025 on SWE-bench Verified at launch.

The bigger idea: the paper argues that training in a simple, checkable workflow builds “skill priors” (finding bugs, editing code, checking its own work) that make it far easier to train full coding agents later.
RUN

How to run Kimi-Dev

Moonshot's example serves the full model with vLLM across 8 GPUs. For a single 48 GB GPU, try a community 4-bit (GGUF) version with Ollama or llama.cpp.

# 1. Get the code git clone https://github.com/MoonshotAI/Kimi-Dev.git cd Kimi-Dev conda create -n kimidev python=3.12 conda activate kimidev pip install -e . # 2. Serve the model with vLLM (8 GPUs, as in Moonshot's example) vllm serve moonshotai/Kimi-Dev-72B --served-model-name kimi-dev \ --host 0.0.0.0 --port 8000 --tensor-parallel-size 8 \ --gpu-memory-utilization 0.95 --max-seq-len-to-capture 131072

Moonshot also offers pre-processed SWE-bench repository data in the GitHub repo to save time when running the benchmark.

WHICH

Kimi-Dev vs Kimi Code and newer models

You want to…UseWhy
Fix bugs and build features day to dayKimi Code with K2.8 Preview or K3.1 ProFar stronger, 1M context, no hardware to run
Research how coding agents learnKimi-Dev-72BOpen weights, open code and a detailed paper
Self-host a coding model on modest hardwareKimi-Dev-72B (quantised)72B fits on one or two large GPUs when quantised
Self-host a frontier coding modelKimi K2.7 Code or K3 open weightsNewer and much stronger, but need far more hardware

Compare Kimi's current coding models: K2.8 Preview, K3.1 Pro, K2.7 Code and K3.

LIMITS

Kimi-Dev limitations

Old by AI standards

Released in June 2025. Kimi's 2026 models score far higher on coding tests, so don't pick Kimi-Dev for quality.

Built for one workflow

It shines in a two-step locate-then-edit workflow. As a free-roaming agent it needs extra fine-tuning.

Hardware hungry

A full-precision 72B model needs multiple data-centre GPUs. Quantised versions trade some quality for size.

Python-centred benchmark

SWE-bench Verified is mostly Python repositories. Test it on your own languages and codebase.

FAQ

Kimi-Dev FAQ

Kimi-Dev-72B is an open-source coding model from Moonshot AI, released in June 2025. It's built to resolve real software issues: it finds the right file, writes a patch and writes tests to check it. It scored 60.4% on SWE-bench Verified, the best open-model result at the time.

Yes. The weights and code are free under the MIT licence on Hugging Face and GitHub, and commercial use is allowed. You pay only for the hardware to run it.

SWE-bench Verified is a set of 500 real GitHub issues, mostly in Python projects. Kimi-Dev produced a patch that passed the project's tests for 60.4% of them, using a two-step locate-then-edit workflow.

No. Kimi Code is Moonshot's coding agent product, which today runs models such as K2.8 Preview and K3.1 Pro. Kimi-Dev is a separate 2025 research model you download and run yourself.

At full precision it needs several data-centre GPUs; Moonshot's example uses 8 GPUs with vLLM. Community 4-bit quantised versions can run on a single 48 GB GPU, with some loss of quality.

They're the two roles Kimi-Dev plays. BugFixer finds the faulty code and patches it; TestWriter writes a test that reproduces the bug. Both use the same model, and at answer time they check each other's work.

For everyday coding, Kimi Code with K2.8 Preview or K3.1 Pro is much stronger. Kimi-Dev is best for research, learning how coding agents are trained, or self-hosting on limited hardware.

Yes. “Kimi-Dev: Agentless Training as Skill Prior for SWE-Agents” (arXiv 2509.23045) was published at ICLR 2026. It shows that skills learned in the two-step workflow transfer to full coding agents.

Want Kimi's best coding model?

Kimi Code runs K2.8 Preview and K3.1 Pro in your terminal, editor or desktop.