Over the past three months, seven leading AI coding agents released more than 200 versions combined. Claude Code moved fastest—94 releases in 106 days. Kimi Code ran from 0.3.0 to 0.24.1, Pi from 0.65.0 to 0.80.7, and Cline jumped from 3.58.0 all the way to 4.0.0.
What were all those versions actually doing? Was there a common direction?
We read through every changelog from all seven. The direction is remarkably consistent. Despite different product forms, business models, and technology stacks, their engineering investment over the past three months converged on three main threads: designing agents like operating systems, turning context compaction from a trick into systems engineering, and evolving from tools into platforms.
First, the Baseline of the Seven
Before diving into the three threads, here is the basic data for all seven products.
| Product | Company | Form | April–July Releases | Releases per Day |
|---|---|---|---|---|
| Claude Code | Anthropic | CLI | 94 | 0.89 |
| Pi | Earendil Works | CLI | 29 | 0.27 |
| Kimi Code | MoonshotAI | CLI | 30 | 0.30 |
| Codex | OpenAI | CLI/IDE/Desktop | 25+ | 0.24 |
| Cursor | Anysphere | IDE | 15 | 0.14 |
| ZCode | Zhipu | IDE | 14 | 0.13 |
| Cline | Cline | IDE plugin | Major version upgrade to 4.0 | — |
Notes: Kimi Code began public releases in May, so there were no April versions; the 30 releases in the table are the May–July total. Codex release counts aggregate the CLI, app, and iOS release channels. Cline moved from 3.58 to 4.0, and 4.0 was a major architectural rewrite.
Window is roughly 106 days from April to July 2026. Cline is a major-version upgrade and is excluded from the comparable release counts.
- Claude Code：94
- Kimi Code：30
- Pi：29
- Codex：25
- Cursor：15
- ZCode：14
The seven products fall into three categories. Vendor-built (model-tied) products—Claude Code, Kimi Code, and Codex—are bundled with their own models and function as extensions of model capability; their iteration cadence usually tracks model releases. Community/open-source (model-agnostic) products—Cline and Pi—take the multi-provider route, connecting to nearly every mainstream model on the market; provider coverage breadth itself is a competitive factor. IDE-integrated products—Cursor and ZCode—originally sold on development environment and user experience. But over the past three months, their focus has not been on IDE features; they too have been evolving into multi-agent platforms.
The difference in release frequency is striking. Claude Code ships 3–6× faster than the others, and the scope is broad: subagent architecture, security hardening, performance optimization, and UI polish are all moving in parallel. ZCode has a respectable number of releases, but bug fixes make up a large share, which suggests product maturity is still ramping up.
Click a category to filter; click again to restore all seven.
Thread 1: Designing Agents Like Operating Systems
This is the most important change of the past three months. The products are no longer satisfied with one-on-one chat-style programming; they are building systems in which AI manages multiple AIs working together.
Every company is doing this, and the concept has already converged. The key term is SubAgent—a main agent spawns several subagents, each executes a subtask, and the results are combined.
| Product | SubAgent / Multi-Agent Features | Key Timeline |
|---|---|---|
| Claude Code | Dynamic Workflows (GA), subagents run in background by default, five-level nesting | April Dynamic Workflows preview, June background-by-default |
| Cursor | Agents Window, cloud subagents, Side Chats | April Cursor 3.0, July Side Chats |
| Codex | Goal mode, multi-agent v2 concurrency | June Goal mode experimental, July multi-agent v2 |
| Kimi Code | Swarm group concurrency, Goal mode, Goal Queue | v0.8 Goal mode, v0.12 Swarm |
| ZCode | General-purpose subagent, background tasks | v3.2 subagent, v3.3 background tasks |
At the feature level, several changes are worth unpacking.
Claude Code's Dynamic Workflows shipped in April and reached GA in May. A single session can orchestrate dozens to hundreds of subagents that execute concurrently in the background, triggered by the word ultracode. Starting in June, subagents run in the background by default and no longer block the main session—the user experience shifted from "stare at the terminal waiting for results" to "fire off tasks and check back later."
Cursor's path is more aggressive. In April, Cursor 3.0 introduced Agents Window, a panel dedicated to managing multiple parallel agents. In May it added Automations, letting agents start automatically from triggers such as Jira, Slack emoji, and GitHub. The June 3.7 release moved agents to the cloud, and the iOS 3.9 client lets users check agent status from a phone. This wholesale shift toward agents is already quite different from Cursor's original positioning as an AI-enhanced IDE.
Kimi Code's approach is lighter. Its /swarm command (v0.12) lets users launch a group of agents with one command, executing concurrently with rate-aware retry and a live progress bar. Goal mode (v0.8) lets an agent keep pursuing the same objective across multiple turns, while Goal Queue (v0.11) supports queuing multiple goals and running them in order. These features do not have the heavy product packaging of Cursor, but the feature set is comparable.
Codex's Goal mode entered experimental release in June; the official description says it can "drive goals for hours or even days." The July multi-agent v2 release added configurable concurrency. At the same time, Codex was merged into the ChatGPT desktop app (macOS + Windows) in July—a change in product form that may matter more than the feature itself.
After ZCode v3.0, it too added subagents and background tasks, but with coarser granularity than the others. Its differentiation lies in deep GLM model integration and team collaboration.
One commonality stands out: background execution is becoming the default. Claude Code's subagents run in the background by default; Cline has background workers; Kimi Code's long-running Bash commands time out and move to the background instead of being killed. This is not a UI tweak—it is a product paradigm shift. The interaction model between user and agent is changing from turn-by-turn chat to "fire off tasks and check back later."
Click a product to highlight its dots; hover a dot to see details.
Hover a dot above, or focus with Tab, to see event details.
Thread 2: Context Compaction Becomes Systems Engineering
Long-running agents hit a structural problem: conversations grow longer, each request carries more context, and cost rises. In 2026, models already support one-million-token context windows—Claude Sonnet 5, Opus 4.8, and Fable 5 all support this natively—but one million tokens is not free. It is expensive and slow. So context compaction is a must-have for every agent product.
Over the past three months, each product's compaction solution has evolved quickly, and the direction is converging.
| Product | Compaction Approach | Key Updates |
|---|---|---|
| Claude Code | Reactive compaction + PreCompact Hook | Debounce detection, fallback model chain, overflow triggers |
| Cline | Unified SDK compaction | Oversized tool-output truncation, assistant-text ceiling, avoiding accidental aggressive truncation |
| Kimi Code | Rewritten compaction summary | v0.21 keeps only the latest user prompt + a single summary |
| Codex | World state replaces traditional compaction | v0.143 turn-owned world state |
| Pi | Cache-friendly dynamic tool loading | v0.80.7 on-demand tool loading, preserves prompt cache |
The products differ in how finely they tune compaction triggers, but the direction is the same: stop truncating brutally and start compressing strategically. Claude Code distinguishes three trigger scenarios—manual, threshold overflow, and context nearing capacity—and introduces a fallback model chain that automatically switches to a cheaper model to perform compression when context overflows. Kimi Code v0.21 rewrote its compaction logic and fixed a bug where tool_use and tool_result became mismatched, ensuring the model can still understand compressed history. Codex introduced the concept of "world state," replacing conversation truncation with structured state.
There is also a cross-product trend: cache-friendly dynamic tool loading. Kimi Code v0.23's experimental select_tools and Pi v0.80.7's dynamic tool loading are essentially the same idea: load MCP tool definitions only when they are actually used, reducing the token count per request while preserving the prompt cache. For users with many MCP servers, this structurally reduces context consumption and the improvement is significant.
The proliferation of one-million-token context windows is also changing compaction design. Larger windows lower the frequency of compaction, but raise the quality bar for each compaction decision—compressed content cannot be recovered. Claude Code's PreCompact Hook, which lets users inject custom logic before compaction, and Codex's world-state approach both address the problem that no compaction can afford to be wrong.
Click a product to see its compaction trigger granularity, cache-friendliness, and on-demand tool loading.
Debounce detection, fallback model chain, overflow triggers; three trigger scenarios (manual, threshold overflow, context nearing capacity).
Values are relative assessments based on changelogs (0–100), directional only.
Thread 3: From Tool to Platform
The third thread is different from the first two. It is not about what users can do with a new feature, but about whether others can build new things on top of it. SDKs, plugin marketplaces, the MCP protocol—over the past three months, every company has been turning from a piece of software into a platform.
SDKs, plugin marketplaces, MCP protocol — five postures of platformization
Differentiation Signals Worth Noting
Beyond the converging big picture, each company has its own emphasis. The radar below compares five of the products across six dimensions; the values are relative assessments based on the past three months of changelogs and are intended for directional comparison only.
Relative assessment based on the past three months of changelogs. Each axis maxes at 100; figures are directional only and do not represent absolute capability.
- Multi-agent orchestration：92
- Context compaction：80
- Platform / SDK：88
- Security governance：95
- Multi-model coverage：70
- Mobile / remote：60
Claude Code invests the deepest and most consistently in security. From April to July, almost every release included security changes: sandbox credential isolation, PowerShell privilege-escalation fixes (trailing &, -ErrorAction Break, TOCTOU attacks), --safe-mode disabling all customization, forced remote-settings refresh (fail-closed), and managed settings version control (requiredMinimumVersion / requiredMaximumVersion). This is aligned with Anthropic's AI safety positioning. In product terms, Claude Code's managed settings offer the finest-grained control among the seven.
Cursor is going mobile. The June 3.9 release opened an iOS public beta—cloud agents + Remote Control + Live Activities (showing agent status in Lock Screen notifications). It is the only one of the seven that has moved agent monitoring to a phone. Given that Claude Code, Kimi Code, and Pi are currently terminal-only, this experience is unique to Cursor for now.
Kimi Code added a Web UI. The v0.17 kimi web command starts a browser chat interface, and v0.21 moved Mermaid and KaTeX rendering into a Web Worker. At the same time, v0.9's ACP (Agent Communication Protocol) lets IDEs such as Zed and JetBrains drive Kimi Code sessions directly. Kimi Code's path is to develop the CLI and browser in parallel.
ZCode's product direction runs against the others. After v3.0, it made a full architectural pivot—from supporting third-party agents to tightly integrating its own GLM kernel, and it no longer maintains third-party adapters. At a time when multi-provider aggregation is becoming the industry mainstream, this is a counter-trend bet. It is betting that "own model + deep integration" can deliver experiences that aggregation cannot, such as grouped task workspaces, Git branch graphs, and status monitoring dashboards.
Pi has the widest provider coverage. New providers added in the past three months include Xiaomi MiMo, Cloudflare AI, Together AI, Moonshot, Ant Ling, and NVIDIA NIM. At the same time, v0.80.6 introduced a max thinking level above xhigh. Pi's strategy is clear: do not bet on any single model; become the best host for all models.
Closing Notes
After reading three months of changelogs from these seven companies, a few observations stand out.
First, subagent and multi-agent orchestration is now the core direction for everyone. Whether it is called Dynamic Workflows, Swarm, or Agents Window, the underlying problem is the same: one-on-one chat programming has limited efficiency, and multiple AIs working together are needed to break past it. And background execution is becoming standard—users do not need to watch the screen while an agent works.
Second, context compaction is no longer a signature feature of any single product; it is infrastructure for everyone. The technical paths are converging too: finer trigger conditions, cache-friendly mechanisms, and on-demand loading. The proliferation of one-million-token context windows has not reduced the importance of compaction; instead, it raises the bar for compaction quality.
Third, platformization is accelerating. Cline is building an SDK, Cursor is building a team marketplace, Codex is merging into ChatGPT, and MCP is becoming standard—these products are no longer just selling coding ability; they are building ecosystems for others to build on top of. Agent software is shifting from a tool that writes code for people to a system that manages AI writing code for people.
Product-form divergence remains large—CLI versus IDE, single-model versus full aggregation, security-first versus mobile-first—and no single approach has clearly prevailed. But the direction is converging: they are all turning agents from tools into infrastructure.