The Coding Agent Land Grab Moves to the Desktop

On 21 September, three companies in three different parts of China's developer market shipped the same kind of thing on the same day. Moonshot released Kimi Code Desktop for macOS and Windows. Alibaba put Qoder, its coding agent workbench, on the HarmonyOS PC app store. Huawei Cloud upgraded CodeArts with a HarmonyOS-focused model, an agent, and a developer practice centre.

Three launches, one message. The fight for the coding agent is no longer about which model writes better code. It is about which window a developer opens first in the morning.

Why the desktop, and why now

An agent that only lives in a browser tab or a terminal has a ceiling. To finish a real task, it needs to read and write files, run commands, look at a rendered page, and check the state of a pull request. Those four things live in different places, and a browser or a CLI can usually reach one or two of them.

A desktop app can reach all four. That is the argument for moving agents out of the chat box and onto the machine. The desktop is the smallest environment where an agent can run a task end to end without a human shuttling context between tools. Moonshot's client is built around that. It ships with an embedded terminal, a browser, screenshot annotation, and a view of Git status and pull request review progress.

The mode names in Kimi Code Desktop tell you what the company thinks agents need. Plan lets the agent propose before it acts. Goal targets longer-running work. Swarm runs multiple agents in parallel, and an experimental mode called Tower coordinates them. Those are all answers to the same problem: an agent that can touch the file system and the terminal is powerful and also easy to let run somewhere you did not intend. Reviewing before acting is not a nicety when the agent can delete a directory.

HarmonyOS as a distribution wall

Alibaba's move is the one worth watching for a different reason. Qoder arriving on the HarmonyOS PC app store is less about the product than about the channel. Huawei claims around 11 million registered HarmonyOS developers. If that number is close to real, the store is the default entry point for a developer population large enough to sustain a tool on its own.

Huawei's numbers are the ones to hold lightly. The company says its HarmonyOS coding model cuts the error rate per thousand lines by more than 80 percent and raises first-compile pass rates by more than 78 percent. Those are vendor figures with no published methodology, and a first-compile pass rate depends enormously on what is being compiled. Treat them as marketing until someone outside Huawei reproduces them.

What is not marketing is the structural position. When an agent ships as the entry point on a platform's developer store, the platform owner controls distribution, and distribution is the harder moat to cross. A competitor with a better model still has to convince developers to leave the store they already open.

JetBrains answers with governance

The most interesting release of the week came a day later, and it was about a different problem. JetBrains launched Air on 22 September, an open system it describes as spanning the IDE, team delivery, and organisational governance. Three products sit inside it: Air for orchestrating and verifying agents inside the IDE, Air Teams for coordinating developers and autonomous agents across a delivery workflow, and Air Governance for policy, visibility, audit, and cost management.

The names matter less than the split. Generation has stopped being the hard part of agentic development. If an agent can write the code, the questions that remain are who reviewed it, who is accountable for it, what it cost, and whether it matches company policy. JetBrains is selling into those questions rather than into generation quality.

That is a deliberate bet on where the money moves next. It is also a way for an incumbent IDE vendor to avoid competing on model quality against Cursor and Codex, which it would probably lose. Instead of arguing that its agent is smarter, JetBrains is arguing that its agent is governable, and it has built the plumbing to back that up. Air works with Claude Agent, Codex, Copilot, OpenCode, and anything speaking the Agent Client Protocol, across IDE, web, CLI, and mobile. A team can bring its own model subscription or pay JetBrains at public API prices.

A shared MCP connection is the small detail that reveals the strategy. Configure a tool connection once, and everyone on the team inherits it. That is the kind of feature that only matters at organisational scale, which is exactly the scale JetBrains is targeting.

The pattern underneath

Step back and the week's releases line up. Microsoft expanded Copilot with a persistent agent that keeps working in the background. UiPath let third-party coding agents generate automation assets that its orchestration layer runs. Webex and Zendesk added agent controls to contact centre and support tooling. The same shift appears everywhere: agents are moving from something you chat with to something that runs in the background against real systems.

That shift creates a new set of problems, and the product announcements are a map of them. Verification, because an agent producing more output than a human can review is not obviously a gain. Attribution, because someone has to sign off on what ships. Cost, because a persistent agent spends tokens while nobody is watching. Governance, because an agent with file system access is a security surface.

The same move, outside the developer world

The desktop land grab is the developer-facing version of a shift happening across enterprise software. Microsoft expanded Microsoft 365 Copilot in late September with Autopilot, a persistent agent that keeps working in the background, alongside new governance controls and agent-to-agent communication primitives. UiPath let third-party coding agents like Claude Code, GitHub Copilot, and Cursor generate automation assets that its orchestration layer then runs. Webex and Zendesk both added agent controls to contact centre tooling.

Every one of those moves takes an agent from something you chat with to something that runs against real systems while you are not watching. That is what makes governance a product category rather than a feature. An agent with file system access, a billing account, and the ability to act autonomously is a small piece of infrastructure, and infrastructure gets audited.

What to watch

For a developer choosing a tool this quarter, the question has changed. It is no longer which agent writes the best code, because the leading models are close enough that the difference is hard to measure. It is which agent fits how your team works and how your organisation reviews what it produces.

For a vendor, the desk is crowded and the differentiation is shifting upward. Model quality is table stakes. The fight is over distribution channels, like a store that ships with a hardware platform, and over governance, like the audit and cost controls an enterprise buys before it lets agents touch production.

The tell will be where the next round of launches lands. If the following month brings more agents and fewer governance tools, the industry is still racing on capability. If it brings controls, audit trails, and cost dashboards, the race has moved to the part that decides whether any of this survives a procurement review.