KAT-Coder-V2.5-Dev: The 35B Mixture-of-Experts Model Built for Autonomous Coding Agents

AI coding models are moving beyond autocomplete.

The newest generation of coding systems is increasingly designed to behave like software-engineering agents: they can inspect repositories, reason about a task, use tools, modify files, execute commands, and iterate toward a working solution.

Kwaipilot’s KAT-Coder-V2.5-Dev is built specifically around that idea.

Released as the open-weight version of KAT-Coder-V2.5, the model combines a mixture-of-experts architecture with extensive supervised fine-tuning and reinforcement learning targeted at agentic coding. It contains 35 billion total parameters, but only around 3 billion parameters are activated for each token, giving it a very different efficiency profile from a conventional dense 35B model. The Hugging Face release is available under the Apache-2.0 license.

Built for Coding Agents, Not Just Code Completion

A traditional coding model might receive a prompt such as “write a Python function” and return a block of code.

KAT-Coder-V2.5-Dev is aimed at a much more demanding workflow.

The model is designed for agentic coding tasks where the AI works inside an executable software environment. Instead of treating programming as a single response-generation problem, the KAT-Coder research focuses on giving the model the ability to operate through tools and interact with real repositories.

That distinction matters.

A real software-engineering task often involves understanding an unfamiliar codebase, locating the relevant files, interpreting existing behavior, editing several components, running tests, reading error messages, and changing the implementation again.

KAT-Coder-V2.5 was specifically trained around this type of interaction, using executable environments and reinforcement-learning workflows rather than relying solely on static code-generation datasets. The technical report describes infrastructure for reconstructing repositories into sandboxed environments, generating task specifications, collecting tool-use trajectories, and rewarding successful executable outcomes.

KAT-Coder-V2.5-Dev brings the resulting post-trained model into an open-weight format that developers can run and integrate themselves.

35 Billion Parameters, But Only 3 Billion Activated

One of the most interesting characteristics of KAT-Coder-V2.5-Dev is its Mixture-of-Experts architecture.

The model contains approximately 35 billion total parameters, but only about 3 billion parameters are activated for a given token. This allows the system to maintain a much larger collection of learned capabilities without processing every parameter for every token.

That is fundamentally different from a dense 35B model.

In a dense architecture, essentially the entire model participates in each forward pass. With a mixture-of-experts design, different expert components can specialize in different patterns while a routing mechanism determines which portions should be active.

For coding agents, this is especially attractive because software-engineering workloads can be extremely diverse.

One task might require understanding Python application logic. Another might involve TypeScript, shell commands, dependency management, SQL, frontend code, or debugging a failing test suite.

A sparse model can potentially provide broad capacity while keeping per-token computation closer to the active expert budget.

A Very Large 262K Context Window

KAT-Coder-V2.5-Dev supports a native context length of up to 262,144 tokens.

For coding agents, a large context window can be far more useful than it might initially appear.

Software projects are rarely contained in a single short file.

An agent may need to reason across source code, configuration files, documentation, tests, dependency definitions, command output, previous tool calls, and changes made during the current session.

A 262K context window gives the agent substantially more room to retain repository information and ongoing task state before older context has to be removed.

This is particularly valuable for repository-level programming tasks, where the objective is not simply generating a function but understanding how multiple pieces of a project fit together.

The model documentation also describes the use of RoPE scaling techniques such as YaRN for workloads that need to go beyond the native limit.

Strong Results on Software Engineering Benchmarks

KAT-Coder-V2.5-Dev is designed around coding agents, and its reported benchmark results reflect that focus.

In the unified evaluation published on the Hugging Face model card, KAT-Coder-V2.5-Dev scores:

• 69.40 on SWE-bench Verified
• 63.00 on SWE-bench Multilingual
• 45.96 on SWE-bench Pro
• 41.02 on Terminal-Bench 2.1
• 93.43 on PinchBench
• 44.20 on SciCode
• 46.21 on KAT-Code-Bench

The same evaluation table places the model ahead of several similarly sized open models on many of these coding-agent evaluations, including Qwen3.5-27B, Qwen3.6-35BA3B, Gemma4-31B, Qwen3.5-35BA3B, Ornith-1.0-35B, Gemma4-26BA4B, and Qwen3-Coder-30B.

The SWE-bench Verified score is particularly relevant because the benchmark is designed around real software-engineering issues rather than isolated algorithmic questions.

However, benchmark comparisons should be treated carefully.

Kwaipilot explains that these figures were reproduced internally using a unified evaluation pipeline with public checkpoints, vLLM or SGLang, and a single evaluation run per benchmark. The company also notes that differences in harnesses, prompts, tools, and evaluation methodology can make results from different reports difficult to compare directly.

The numbers are therefore best understood as evidence of strong performance within the reported evaluation setup rather than a universal ranking of every coding model.

PinchBench Shows the Agentic Focus

PinchBench is another important result.

KAT-Coder-V2.5-Dev reaches 93.43 on the benchmark in the Hugging Face evaluation table, compared with 90.71 for Qwen3.5-27B and 92.21 for Qwen3.6-35BA3B.

This is significant because KAT-Coder is not trying to optimize only for static code generation.

Its broader research program is focused on models that can act through tools and operate inside real environments.

The KAT-Coder-V2.5 technical report describes a training strategy involving executable environments, tool-use trajectories, reinforcement learning, randomized agent harnesses, and specialized experts for software engineering and agentic tasks.

That makes the model particularly interesting for developers building coding agents rather than simple code assistants.

Reinforcement Learning for More Reliable Tool Use

One of the less glamorous but more important problems with coding agents is reliability.

Generating a correct line of code is only part of the challenge.

The agent also has to use tools correctly.

It needs to produce valid tool calls, interpret tool responses, avoid getting stuck in loops, and maintain coherent behavior over many turns.

Kwaipilot reports that reinforcement learning substantially reduced several abnormal behaviors in KAT-Coder-V2.5-Dev. According to the model card, abnormal tool-label behavior dropped from 9.34% to 0.28%, while the reported single-turn continuous-repetition rate fell from 0.34% to 0%.

Those improvements may not appear as impressive as a benchmark score, but they are extremely relevant to real-world agents.

A coding agent that writes slightly better code but frequently produces malformed tool calls can become frustrating to use.

Reliable interaction is part of the model’s actual capability.

Open Weights Make the Model More Interesting

Another major advantage is that KAT-Coder-V2.5-Dev is open-weight and released under Apache-2.0.

That makes the model attractive for developers who want more control over their coding infrastructure.

Instead of depending entirely on a proprietary API, teams can experiment with the model in their own environments, evaluate it against private repositories, build custom agent frameworks, and integrate it into internal development tools.

This is particularly valuable for organizations that cannot send proprietary source code to an external service.

The model can also be quantized and used through a growing ecosystem of local inference tools. Its Hugging Face page links to compatible quantizations for environments such as llama.cpp, Ollama, and LM Studio.

The practical hardware requirements will still be substantial because the model has 35B total parameters, but the 3B activated architecture gives it a much more interesting efficiency profile than a conventional dense model of the same total size.

Transformers, vLLM, and SGLang Support

KAT-Coder-V2.5-Dev is not restricted to one specialized runtime.

The official release provides examples for Hugging Face Transformers, vLLM, and SGLang, with additional integration paths through KTransformers and Docker-based workflows.

For example, the Hugging Face implementation can load the model through Transformers using the standard model identifier:

Kwaipilot/KAT-Coder-V2.5-Dev

For production-oriented serving, the project provides vLLM and SGLang configurations.

The vLLM documentation recommends using the language-model-only mode because the open-weight release contains the language-model weights without the vision tower. The example configuration supports a 262,144-token context window with tensor parallelism.

SGLang provides a similar serving path and supports tool-use parsing configurations for the model.

That gives developers several choices depending on whether they are experimenting locally, running a private inference server, or building a larger coding-agent infrastructure.

An Important Limitation: The Open Release Is Text-Only

There is an important detail that developers should not overlook.

The KAT-Coder family has multimodal capabilities, but the public KAT-Coder-V2.5-Dev Hugging Face release does not include the vision components.

The model card explicitly states that the open-weight release contains only the language-model weights and operates as a text-only model. The vision and multimodal components are not included in this checkpoint.

This means developers should not treat the Hugging Face checkpoint as a fully multimodal coding model simply because the model repository carries image-text-to-text metadata.

For the open checkpoint, the practical focus is text, code, tool use, and agentic software engineering.

That distinction is important when designing an application around the model.

What Makes KAT-Coder-V2.5-Dev Different?

There are many open coding models available, but KAT-Coder-V2.5-Dev takes a different approach from models primarily optimized for autocomplete or conversational programming.

Its design is centered around autonomous software engineering.

The research behind KAT-Coder focuses on the complete loop:

understanding a task → planning → using tools → modifying code → executing the repository → observing results → correcting mistakes → completing the task.

That is much closer to how a human developer actually works.

The KAT-Coder-V2.5 technical report describes the use of AutoBuilder to reconstruct multilingual repositories into sandboxed environments and KwaiClawEnv to generate large-scale tool-use trajectories from executable services. It then combines reinforcement learning, harness randomization, a reliability-focused sandbox, and multi-teacher on-policy distillation to improve agentic behavior.

The goal is not simply to make the model better at predicting the next line of code.

The goal is to make it better at completing software-engineering tasks.

Where KAT-Coder-V2.5-Dev Makes Sense

The model is particularly well suited to applications where the AI needs to interact with an actual development environment.

Autonomous Coding Agents

Developers can use KAT-Coder-V2.5-Dev as the reasoning engine behind agents that inspect repositories, edit files, execute commands, and run tests.

Repository-Level Bug Fixing

Its long context and coding-agent training make it suitable for tasks where understanding several interconnected files is necessary before a useful fix can be produced.

Automated Testing and Debugging

An agent can generate a change, run tests, inspect failures, and iterate instead of stopping after the first generated answer.

Terminal-Based Development Agents

The model’s strong Terminal-Bench performance makes it relevant to agents that interact with command-line environments and developer tooling.

Private Enterprise Coding Infrastructure

Because the model is open-weight and Apache-2.0 licensed, teams can explore self-hosted deployments for internal codebases and development workflows.

AI-Powered IDE Features

KAT-Coder-V2.5-Dev can serve as the foundation for more ambitious IDE assistants that go beyond autocomplete and actively work through multi-step engineering tasks.

It Is Not Just a Bigger Coding Chatbot

The most interesting way to think about KAT-Coder-V2.5-Dev is not as another chatbot that happens to write code.

It is better viewed as an engine for coding agents.

That difference changes how developers should use it.

A chatbot might answer:

“Here is how you could fix this bug.”

A coding agent is expected to actually investigate the repository, find the bug, implement the change, run the tests, examine the output, and continue until the task is solved.

KAT-Coder is explicitly trained around the second scenario.

That is why benchmarks such as SWE-bench, Terminal-Bench, and PinchBench are more relevant to the model than conventional programming benchmarks alone.

The Trade-Offs

KAT-Coder-V2.5-Dev is powerful, but it is not a universal solution.

First, 35 billion total parameters still make it a serious model to host. A 3B active parameter count does not mean the complete checkpoint is only a few billion parameters.

Second, running a model with a 262K context window can require significant memory and serving infrastructure, especially when multiple users or long sessions are involved.

Third, the public checkpoint is text-only, so applications requiring image understanding cannot simply use this release as a multimodal model.

And finally, benchmark results should not be interpreted as proof that the model will automatically solve every repository. Real-world software engineering is highly dependent on the agent harness, tools, repository quality, test coverage, prompts, and environment.

KAT-Coder’s own evaluation notes emphasize this point by documenting differences between benchmark configurations and evaluation harnesses.

Why Developers Should Pay Attention

The bigger story behind KAT-Coder-V2.5-Dev is the evolution of open coding models.

The first wave of AI coding assistants was mainly about autocomplete.

The next wave became conversational: ask a question, receive code, ask for modifications, and repeat.

The agentic wave is different.

The model is expected to operate.

It should understand the repository, interact with tools, run commands, observe failures, and keep working toward a measurable objective.

KAT-Coder-V2.5-Dev is a strong example of this shift.

Its 35B MoE architecture provides large total model capacity while activating roughly 3B parameters per token. Its 262K context window gives coding agents substantial room for repository information. Its reported scores across SWE-bench, Terminal-Bench, PinchBench, SciCode, and KAT-Code-Bench demonstrate why the model is attracting attention in open agentic coding.

And because the model is open-weight under Apache-2.0, developers are able to experiment with that technology outside a closed API.

What Developers Can Build With KAT-Coder-V2.5-Dev

1. Autonomous repository agents: Build agents that inspect codebases, modify files, execute shell commands, and iterate based on test results.
2. AI debugging systems: Give the model a failing repository and let it investigate stack traces, identify likely causes, and implement fixes.
3. Long-context coding assistants: Use its 262K-token context to work with large amounts of repository code, documentation, and tool output.
4. Terminal coding agents: Build development assistants that operate directly through terminal environments and command-line tools.
5. Private coding infrastructure: Deploy the open model inside a controlled environment for internal engineering workflows.
6. IDE agents: Combine the model with code search, file editing, terminals, test runners, and Git operations to create a more autonomous development assistant.

Final Verdict

KAT-Coder-V2.5-Dev is one of the more interesting open models for developers who want to build serious coding agents rather than another simple code chatbot.

Its combination of 35 billion total parameters, roughly 3 billion active parameters, a 262K-token context window, agentic-coding optimization, strong reported software-engineering benchmark results, and Apache-2.0 licensing makes it a compelling foundation for autonomous coding systems.

The most important thing to understand is what the model is actually designed to do.

It is not primarily about predicting the next line of code.

It is about completing engineering tasks.

That makes KAT-Coder-V2.5-Dev a model worth watching as AI coding continues moving from autocomplete toward autonomous software development.

For developers building the next generation of coding agents, the interesting question is becoming less about whether AI can write code.

The question is whether AI can actually work on a software project.

KAT-Coder-V2.5-Dev is designed around that question.