KwaiKAT Launches KAT-Coder-Pro V2.5, Showcasing Advanced Coding Capabilities

China’s homegrown Coding model is dominating! Kuaishou’s KAT-Coder-Pro V2.5 successfully closed a real bug in just 1 minute and 20 seconds, and manually wrote 1,395 lines of code to recreate Minecraft—its long-range engineering capabilities rival Opus 4.8. No more need to act as an AI babysitter.

Article author and source: AI New Era

Has AI coding really reached this level after hands-on testing?

No matter how impressive the claims, real-world performance speaks louder. Next, we’ll put KAT-Coder-Pro V2.5 through a variety of real-world scenarios to thoroughly test its capabilities.

No more suspense—here’s the reveal: the AI integrated into CC is KAT-Coder-Pro V2.5, released by Kuaishou, a flagship agentic coding model. While other AIs are still competing to “help you fix a snippet of code,” this one aims to solve the entire project for you. This is precisely the ultimate gap that all coding models face.

The previous penalty kick demo was just a warm-up; now let’s ramp up the intensity for V2.5 and recreate Minecraft in real time.

The prompt also has over 400 lines. Compress it to something like this:

A single HTML file, Three.js, first-person. Fourteen types of blocks, each with hardness, transparency, and collision properties; bedrock is indestructible. All textures must be procedurally generated as 16×16 pixel canvas images—no external textures allowed. A procedurally generated island using a fixed-seed noise function, featuring hills, coastline, shallow water, and underground mineral veins. Procedurally generate an oak forest, plus a walk-in woodland cabin (wooden floor, log pillars, glass windows, cobblestone roof, brick chimney), and lay a cobblestone path from the spawn point to the cabin. Aim to display wireframes; hold the left mouse button to show a progress bar; when broken, drop particle fragments. Audio effects are synthesized in real time using Web Audio.

Immediately, a playable Minecraft world is complete. Click “Enter World,” and your mouse is locked to the screen. Beneath your feet lies grass, above you stretches a blue sky, and a path of cobblestone extends from your feet, winding past an oak tree toward a small house behind it—wooden planks for walls, log pillars, a cobblestone roof, and a brick chimney, with glass windows set into the walls all around. Next, walk toward an open area in front of the house, hold down the left mouse button, and with a soft “pop,” the grass block breaks. A dozen small green cubes spring out of the hole, tumbling downward. The color of the debris matches exactly the color of the block you just mined. Then, switch through the toolbar to select materials like sand, oak wood, and stone—it’s time to build something amazing. To your delight, within this world, you also witness a sunset that paints the entire sky.

Let’s test another interactive one: have V2.5 create a solar system with its bare hands. To probe its limits, we imposed extremely stringent constraints:

1000+ lines of prompts, with the main key points as follows:

Single HTML, pure Canvas 2D, no Three.js. All eight planets and eleven moons must use true J2000 orbital elements—semi-major axis, eccentricity, inclination, longitude of ascending node, argument of periapsis, mean anomaly. Strictly prohibit angle += speed. Both planets and moons must solve Kepler’s equation using Newton-Raphson iteration, sharing the same daysSinceJ2000. Venus and Uranus must have negative rotation. Triton must orbit retrograde with an inclination of 157.3°. Saturn’s and Uranus’s rings must be drawn in two passes—front and back—to allow planets to occlude them. At high speeds, moons must switch to trail mode to prevent flickering. When paused, planetary surface rotation must halt; when rewinding, everything must reverse. All planetary surfaces must be procedurally rendered: Jupiter must feature the Great Red Spot, rotating across the visible hemisphere; Earth’s continents must vanish when rotated to the far side and reappear from the opposite side. Additional features: eight time speed levels, two orbital scale modes, virtual camera tracking, 700 fixed-seed stars, asteroid belt, Kuiper belt, responsive layout, nine keyboard shortcuts.

Faced with such complex requirements, V2.5 demonstrated textbook-level engineering thinking. It precisely decomposed the entire project: from architecture design and orbital calculation strategies, to the global dual-track ratio system and starfield background generation,再到 main star rendering, layered planetary ring rendering, and the coordinated management of the complex satellite system. All modules progress layer by layer, with flawless logical coherence. Without further ado, let’s move straight to the demonstration.

Open this webpage, and in the center is today’s date, while the eight planets on screen are positioned exactly where they truly are at this moment. This is not just an illustration of the solar system—it’s a fully functioning solar system! The Sun sits at the center, with the planets arranged around it. Between Mars and Jupiter, a ring of fine dust slowly rotates—the asteroid belt. Every celestial body, every moon, and every cloud on planetary surfaces is driven by the same simulated time. When you press pause, the planets stop orbiting, the moons stop revolving, and Earth stops rotating. Click on Saturn, and a data panel slides out to the right. In the small preview window at the top of the panel, Saturn slowly rotates on its axis, its rings turning along with it, with perfect occlusion and layering. This no longer feels like a school project—it feels like a live product.

Next, we threw KAT-Coder-Pro V2.5 into a real open-source bug. The result was far more thrilling than benchmark scores. The issue came from humanize, a real Python open-source library. In 2024, it had a genuine bug: naturaldelta(timedelta(hours=-5)) should have returned “5 hours,” but instead it said “a day.” Negative five hours were incorrectly translated into an entire day. We rolled the repository back to the commit where the bug still existed, gave it nothing but the issue report, and let it work completely on its own—no hints, no guidance. After searching two patterns and reading two files, it directly diagnosed the problem: Python stores negative timedeltas in two’s complement form, so timedelta(hours=-5) is internally represented as days=-1, seconds=68400. The original code took abs() of each component separately—turning -1 day into +1 day while leaving 68400 seconds unchanged, artificially combining them into “1 day + 19 hours.” This root cause analysis matched the official fix exactly—two’s complement storage, inconsistent signs between components, and incorrect abs() application per component. However, its proposed solution differed from the official one: while the official fix took the absolute value of the entire timedelta, it chose to first convert to total seconds and then re-split them. By the way, this entire round ran on Claude Code—which is explicitly named in the official Harness Scaling training environment alongside mini-swe-agent, Codex, and OpenClaw. We run repeated trials across multiple frameworks precisely to ensure “no framework-specific dependency.” In practice, it proved perfectly adaptable—showing zero signs of “framework shock.”

The last question isn’t about fixing a bug—it’s about adding an entire new set of features to a live system. Everyone has experienced it: you upload a 1 GB file, it gets to 92%, then the network drops. You refresh—and it starts over from 0%. The solution is called chunked uploading: split the file into a thousand pieces, and when it fails, only re-upload the missing chunks. It sounds simple—slice, upload, reassemble. But the challenge isn’t those three steps; it’s the messy chaos in between:

Fragments arrived out of order. The client retransmitted due to disconnection, but the server couldn’t distinguish whether it was a retry or an overwrite. After a server restart, 700 fragments on disk became orphaned. Even if all fragments arrived, it still doesn’t guarantee correct transmission.

It ran for 20 minutes and 12 seconds. The solution involved dividing the disk into three compartments: published, progress metadata, and incomplete fragments. Fragments always remain in chunks/, physically inaccessible to the published area. Metadata is first written to a temporary file, then atomically renamed. This is because the process might crash midway through writing progress, leaving behind corrupted partial data. By writing the full data first and then renaming in one step, the operation either succeeds completely or fails entirely. After a restart, a quick scan restores the progress immediately. Fragment duplication is handled by byte-by-byte comparison. A lazy approach would be: “If a fragment exists at this position, treat it as a duplicate and allow it.” But this implementation checks each byte individually: if there’s even a slight discrepancy, it throws an error and leaves the original data untouched. The final deliverable consists of eight files, approximately 1,400 lines of code, five new APIs, and 26 upload tests—all implemented with browser-side support for pause/resume and refresh recovery. Running npm test yields 33 tests, all passing. None of the five existing interfaces were broken. The key to solving this problem was remembering every single “what if…” scenario during those twenty minutes. In real software engineering, ninety percent of the effort goes into handling these “what ifs.”

The agent's engineering-level capabilities are nearly on par with Opus 4.8

Let’s take another look at KAT-Coder-Pro V2.5’s performance on real-world leaderboards. On PinchBench, which measures agentic tool usage capability, KAT-Coder-Pro V2.5 scored 94.2, outperforming Opus 4.8. On SWE-Bench Pro, widely regarded as the most challenging repository-level software engineering benchmark, it achieved 65.2—just behind Opus 4.8 (69.2)—and significantly surpassing a range of domestic models. Additionally, on KAT Code Bench, an internally constructed real-world engineering evaluation set, it scored 53.1, placing it firmly in the second tier; on KAT Claw Bench, a business-oriented agentic evaluation set, it earned 85.5, closely competing with the strongest open- and closed-source counterparts. Within the broader coding model landscape, this represents a genuine leap into the top tier. Having seen KAT-Coder-Pro V2.5’s real-world capabilities, it’s time to explore the engineering innovations behind it.

Core Technology Breakdown

This time, the KwaiKAT team conducted a systematic upgrade centered on “longer task chains and more complex business workflows.” Specifically, KAT-Coder-Pro V2.5 achieves comprehensive breakthroughs across three key dimensions:

Long-range engineering capabilities, general agentic abilities, and the large-scale agentic reinforcement learning system that supports them all.

High single-file benchmark scores and actually delivering results in a project are two different things.

The reality that must be acknowledged: asking an AI to “fill in a function” and asking it to “complete an entire engineering task” are two entirely different levels of capability. The former is already well within the grasp of today’s models. But real software engineering always presents a different face. In long-range repository tasks, models most commonly fail in three ways: mislocating cross-file references, ignoring project conventions, and submitting work without passing tests. The true bottleneck, however, often lies in a counterintuitive place: what stalls the model is rarely how much code it has read, but how many real projects it has successfully run end-to-end. The challenge is that setting up runnable, verifiable repository environments at scale is extremely difficult—industry-wide success rates for direct setup have long hovered around just 16.5%. In other words, getting even one out of six repositories working properly is considered good. KwaiKAT’s solution is AutoBuilder, which turns the model into its own “environment engineer”: analyzing repositories, generating configurations, and verifying within isolated sandboxes whether tests are truly executed—if not, it automatically iterates and fixes. The results are immediate: environment setup success rates jumped from 16.5% to 57.2%, accumulating over 100,000 runnable and verifiable repository environments spanning 12 programming languages. The types of changes within these environments cover bug fixes, feature additions, interface compatibility, cross-module interactions, and regression repairs—nearly mirroring every scenario encountered in real-world development. This is the “training workshop” of V2.5. There’s also a clever twist in data processing. The industry typically keeps what’s correct and discards what’s wrong—but KwaiKAT deliberately mines value from failures. Many failures are just one step away from success: the direction is right, the location is accurate, but a single critical judgment is missing. The team isolates these samples, reapplies targeted prompts, and achieves a roughly 20% conversion rate into reproducible, high-quality training data. As a result, the model doesn’t just learn “how to do it right”—it learns something even more valuable: “how to recover when it goes wrong.”

General Agentic, from "able to use tools" to "capable of handling business operations"

Writing code is only half of agentic capability. The other half is mastering real-world business workflows. Existing tool-use evaluations mostly involve atomic tasks—checking the weather, booking a ticket, wrapping up in about five steps. But real business workflows are on an entirely different scale; for example:

Read the top trending topics across multiple platforms for the past week, filter out entries related to the short video industry, extract the top five trending items per platform, and produce a concise report with sections and word limits, ordered by date in descending order, without fabricating any data.

This type of task involves over ten rounds of interaction, wrapped in a host of implicit formatting and consistency constraints—break one link, and the entire process fails. Like long-range engineering, this capability is honed in the "workshop." On the code side, AutoBuilder handles it; on the business side, KwaiClawEnv takes over, forming a three-layer closed-loop collaboration:

• The Service layer dynamically expands pools and converts a large volume of community skills into deployable services.
• The Task layer generates countless task variants seeded from real-world business scenarios;
• The Eval layer uses a dual-filtering approach of "hard rules + model review" to retain only executable, verifiable, and naturally behaving trajectories.

The training data generated includes an average of 15 tool calls per trajectory, with some exceeding 100 steps, covering data analysis, cross-system integration, batch document processing, and report generation—tasks that thousands of R&D and business teams at Kuaishou face daily.

Large-scale reinforcement learning enables AI to learn "how to do it" on its own.

Supervised fine-tuning allows the model to mimic examples, but it becomes confused when faced with unfamiliar errors or unexpected feedback. What truly teaches a model to explore, correct itself, and verify is large-scale reinforcement learning. The KwaiKAT team focused their efforts on the following three areas:

First, scaffold scaling is unlimited.

Put the model through rigorous practice across multiple frameworks such as mini-swe-agent, Claude Code, Codex, and OpenClaw. These frameworks differ significantly in their calling protocols, context management, and control flow, forcing the model to develop its core competence in solving tasks—so it remains effective regardless of the framework.

Second, long-term credit allocation.

Across hundreds of interactions, which specific step led to the successful outcome? The team used asymmetric PPO: during execution, the model only sees real-environment information, while the training critic gains an additional “god’s-eye view”—allowing rewards and penalties to be precisely assigned to individual steps based on whether the final test passes and the quality of the patch, avoiding the pitfall of “one wrong step ruining everything.”

Third, a three-tier reward system.

Lock in genuine test results at the top level to eliminate cheating through manipulated scores; standardize engineering practices such as tool invocation and cleanup of temporary files at the middle level; and provide positive feedback at the base level for valuable failures like “accurate positioning with partial test coverage,” safeguarding the model’s curiosity. Notably, the team initially believed low rewards were due to algorithmic issues, but investigation revealed the root cause was the training environment itself—early on, approximately 16% of trajectories contained at least one failure originating from the sandbox rather than the model. After a rigorous infrastructure overhaul, sandbox feedback error rates were reduced to below 2%, and training crash frequency dropped by roughly an order of magnitude. It is these unglamorous foundational efforts that have enabled the subsequent stable training.

A model that encompasses five capabilities

Long-range reasoning, general agentic behavior, terminals, frontend aesthetics, and general knowledge—KwaiKAT trained one expert for each of these five areas. The challenge lies in integrating them into a single model while avoiding the "press down one end, the other rises" seesaw effect. The team’s solution is MOPD (Multi-Teacher Online Policy Distillation): the student solves problems on its own, and for each problem, the relevant expert provides guidance; capabilities are fused in function space rather than through rigid parameter merging.

A KAT-Coder-Pro V2.5 that combines the expertise of five specialists—all in one, no switching needed during deployment—write code, run workflows, and build pages, all handled by a single tool.

The highly praised front-end aesthetics from the previous version have been fully carried forward to this one, perfectly validating this approach: new capabilities have been significantly expanded, while existing ones remain untouched. This relentless reconstruction has directly forged the most compelling track record.

The second half of coding is all about "engineering."

Behind KAT-Coder-Pro V2.5 is a clear-eyed realization: the bottleneck to strengthening programming models has shifted from “how large is the model” to “how solid are the surrounding infrastructure components.” As a result, environment setup, trajectory synthesis, RL stability, and capability integration are all treated as first-class system engineering challenges. The result is a precise capability profile—top-tier agentic tool usage, combined with repository-level engineering capabilities that are among the most advanced globally. For developers, this means you can finally entrust an entire issue or a full workflow to the AI without needing to babysit it. KAT-Coder-Pro V2.5 is now fully live and available for immediate use. To get started: call the API directly via StreamLake.com (Model ID: kat-coder-pro-v2.5).