Agentic AI AI JetBrains New Products News Releases

JetBrains Air：构建面向 Agentic 软件开发的产品体系

AI 可以生成代码，但组织仍必须交付软件。Agentic 开发正在改变软件的构建方式，但并没有改变犯错的代价。

六个月前，我们开始公开试验 Agentic 开发环境。大约在同一时期，我们推出了 JetBrains Central，将其作为一个面向 Agent 驱动开发的开放控制与执行系统。随后，我们开始为团队和组织逐步推出 JetBrains Central CLI、共享上下文、云端 Agent、自动化、治理能力以及 AI 成本控制功能。

今天，我们将这些工作整合为 JetBrains Air：一套面向开发者、团队和组织的开放且连贯的产品体系，可在 JetBrains IDE 内外使用。它覆盖多个界面和多项服务。每个产品解决不同的问题，但它们组合使用时效果更佳。

JetBrains Air 标志着 JetBrains 正在构建的目标范围显著扩大。过去 26 年里，我们主要专注于个人开发者工作台。如今，我们正为更广泛的系统构建产品：Agentic 工作在其中被发起、执行、协调、审查和治理。

IDE 对 JetBrains 的未来仍然至关重要。整个软件开发系统能够被容纳在一个窗口中的时代正在结束。作为持续投入的一部分，我们如今正将基础 Agentic 体验引入 JetBrains IDE，为专业开发者提供一个能够高效与 Agent 协作、同时理解、修改和验证其生成代码的环境。JetBrains Air 则连接起围绕这一环境不断发展的更广泛系统。

该系统基于一项核心信念：Agentic 开发的未来将是多供应商的。没有任何单一模型、Agent 或服务会适合每一位开发者、每一个团队或每一项任务。

从单一产品到开放的产品体系

这一战略转变带来了一个实际结果：JetBrains Air 不能只是又一个 Agent 或开发环境。它必须连接面向个人工作的产品、团队协同、组织控制、上下文和流程自动化能力，同时持续对开发者选择的工具和 Agent 保持开放，包括 JetBrains 自身并不构建的产品。

JetBrains Air 包含当前已可用的产品，以及随着体系发展将陆续推出的其他产品：

• JetBrains IDE 中的 Air：一套完整的 Agentic 开发体验，可在 JetBrains IDE 中指挥和编排 Agent，并验证其工作成果。
• Air Teams：一种新的方式，用于协调和自动化涉及开发者与自主 Agent 的软件交付工作流。
• Air Governance（原 JetBrains Central）：为 AI 辅助和 Agent 驱动开发提供组织政策、可见性、可审计性、成本管理和责任追踪能力。

Junie 是 JetBrains 面向专业软件开发的编码 Agent。它将获得所有 Air 使用界面的支持。

JetBrains IDE 中的 Air 为开发者提供了借助 JetBrains 代码智能来指挥 Agent、验证其输出的环境。Air Teams 将单个 Agent 的活动转化为协调一致的团队工作流。Air Governance 则让这些活动在整个组织内变得可见、可治理且可追责。

但一个开放系统不能止步于 JetBrains 自身的产品。Agent Client Protocol（ACP）对 IDE 与 Agent 完整运行框架之间的连接进行了标准化，其中包括其规划、逻辑、工具、模型路由和可观测性。通过 ACP Registry，开发者可以发现并运行越来越多的兼容 Agent，同时继续在 JetBrains IDE 内工作。

Air Governance 的设计目标是，将可见性和成本治理扩展至不同供应商，以及 Agentic 工作发生的各种工具。这意味着开发者可以选择适合任务的 Agent、模型或服务，而无需迫使组织放弃上下文、可见性或控制能力。

Air 的各项产品共同使工作能够在开发者、Agent、工具和环境之间流转，同时不丢失围绕这些工作建立的上下文和控制机制。

个人采用速度已超过组织基础设施建设速度

自 3 月以来，我们的产品取得了显著进展，但我们对 Agentic 开发所需条件的理解也在不断加深。

开发者采用 Agent 的速度，已经超过组织围绕它们构建基础设施的速度。Agent 的能力持续进步，不同模型和 Agent 已被证明适合不同任务。然而，围绕它们的上下文、协同、治理和成本管理能力并未同步跟上。

对于许多开发者而言，Agent 已经带来实际价值。但在组织层面，其经济效益要更难证明。成本会在其他环节显现：审查、返工、安全、基础设施和支出。

哪些 Agent 可以访问公司代码？数据可以流向何处？哪些输出需要人工审查？Agent 远程工作时发生了什么？谁批准了最终变更，又是如何验证的？

这一层面的碎片化不只是令人烦扰。恰恰在更多工作被委派出去的时刻，它使软件开发更难被理解、衡量和治理。

瓶颈正在随着工作发生转移

明显错误的代码会很快被发现。系统在这一方面仍然运转良好。更难的问题是那些几乎正确的代码：它们看起来合理，能够通过表面的检查，却暗中带有错误假设或架构不一致性，而这些问题直到代价高昂时才会暴露。

随着 Agent 承担更多执行工作，瓶颈正从产出变更转向理解、验证和对变更负责。代码生成的成本变低，但验证成本变高。Agent 活动更容易发起，却更难协调、审计和解释。

而且，工作可以委派，责任却不能。凌晨 3 点系统出现故障时，接到电话的不会是 Agent。对发布内容的责任，仍属于发布它的人和组织。

这就是为什么随着 AI 能力提升，控制反而会变得更难，而不是更容易。能力更强的模型可能生成更好的输出，但它无法制定组织政策、保留来源与演变记录、提供成本可见性，或决定谁来接受对最终变更的责任。

未来将是多供应商的

多供应商支持是 JetBrains Air 的基础设计原则，并从一开始就塑造着该系统的构建方式。

我们不认为这个市场会在短期内整合。不同模型各有擅长之处，排名每隔几个月就会变化。同一家公司内部的团队已经在做出不同选择，而这样做往往是正确的。今天标准化采用一家 AI 供应商，意味着要在一个下个季度就可能面貌不同的市场中做出多年承诺。

保持选择开放是合理之举。问题在于，开放目前所付出的代价。组织每增加一个模型、Agent 或服务，就会失去一些对自身开发工作的可见性。上下文无法在工具之间传递。支出无法归因。政策必须为每项服务重新构建。

组织不应被迫在使用最佳可用工具与理解自身工程体系内正在发生什么之间二选一。之所以存在这种权衡，是因为当前技术栈中没有任何东西被设计为可同时位于多个供应商之上。

这正是 JetBrains 正在承担的工作。我们构建自己的 Agent，并打算将其打造得足够出色。但 JetBrains Air 不要求客户使用我们的 Agent，我们的战略也不依赖于本季度哪家模型提供商位居排行榜首位。我们没有理由让生态系统变得比现在更小。

我们能够提供的，是一个统一的位置：让开发者、团队和组织可以跨越每一个模型、Agent 和服务，运行、查看、治理和核算 Agentic 开发。

支持多个模型和 Agent 只是基础，而非终点。真正重要的是位于它们之上的能力：共享上下文、一套统一政策、统一成本视图，以及无论由哪家供应商产出变更都完整保留的活动记录。

为什么是 JetBrains？

多供应商选择只能解决部分问题。Agent 同样需要可靠的软件智能。

JetBrains 为这一问题带来了 26 年的工程智能积累，帮助开发者理解复杂软件的结构和行为，而不只是生成更多代码。这种确定性的代码智能，为提升不同模型和 Agent 上 Agentic 工作的可靠性、效率与可理解性提供了基础。我们已经看到，让 AI Agent 访问确定性代码智能所带来的积极成果。

这不仅是技术优势，也是经济优势。Agent 会花费时间和资金，重新发现代码库中已经存在的信息。能够获取这些知识的 Agent，比必须自行重构这些知识的 Agent 更便宜也更准确。由于这种智能不属于某一个模型，其收益可以扩展到所有受支持的 Agent 和服务。

我们也正在经历与我们所服务组织相同的转型：在内部采用 Agent、重新设计工作流，并学习哪些个人生产力提升能够转化为更好的软件交付，哪些只是将工作转移到了别处。

接下来会发生什么

JetBrains Air 将通过持续滚动的一系列版本发布不断发展。我们会明确说明客户当前可以使用什么、哪些功能正在进入预览，以及哪些仍属于我们的长期方向。

随着时间推移，JetBrains Air 将进一步扩展到移动端和远程体验，使人们能够在工作跨环境流转时发起、监控、审查和继续 Agentic 工作。目标并不是在每一个界面上复刻 IDE，而是在需要做出决策的任何地方提供恰当的上下文和控制能力。

我们还将把 JetBrains 的智能能力带入更多 Agentic 工作流。这包括从代码、架构、仓库、运行时行为和组织知识中提取的更丰富上下文，以及在开发者、模型、Agent 和服务之间更好地路由工作的方法。

更多工作将由仓库事件、计划任务和交付流程触发，而不再只是由开发者打开编辑器并输入提示词触发。JetBrains Air 将跨越不同界面和服务，提供这些工作流所需的智能、监督和人工控制。

在未来产品的范围和可用性准备好得到确认之前，我们不会为其命名。随着每次发布，我们都会说明哪些功能可用、它们如何连接，以及哪些内容仍在推进中。

JetBrains Air 的发展方向

成功采用 AI 的公司，未必是生成代码最多或部署 Agent 最多的公司。它们将是那些能够扩大试验规模，同时不失去质量、上下文、成本纪律或人类理解能力的公司。

JetBrains Air 是我们对这一现实的承诺。它将 JetBrains 从开发者工作台扩展为一套连接开发者、Agent、团队和组织的产品体系。

目标不是更多代码，而是开发者、团队和组织能够理解、验证并愿意为之负责的软件。

Agentic AI AI JetBrains New Products News Releases

JetBrains Air: Building a System of Products for Agentic Software Development

AI can produce code. Organizations still have to produce software. Agentic development is changing how software gets made, but it hasn’t changed what it costs to be wrong.

Six months ago, we began publicly experimenting with agentic development environments. Around the same time, we introduced JetBrains Central as an open control and execution system for agent-driven development. We subsequently began rolling out JetBrains Central CLI, shared context, cloud agents, automations, governance, and AI cost controls for teams and organizations.

Today, we are bringing this work together as JetBrains Air: an open, coherent system of products for developers, teams, and organizations, inside and beyond JetBrains IDEs. It is multi-surface and multi-service. Each product solves a distinct problem, but the products work better together.

JetBrains Air marks a significant expansion in what JetBrains is building for. For 26 years, we have focused primarily on the individual developer workbench. Now, we are building for the wider system through which agentic work is initiated, executed, coordinated, reviewed, and governed.

The IDE remains important to JetBrains’ future. The era in which the whole software development system can be contained in one window is ending. As part of our continued investment, we are now bringing the foundational agentic experience into JetBrains IDEs, giving professional developers an environment where they can work effectively with agents while understanding, changing, and verifying the resulting code. JetBrains Air connects the wider system developing around it.

That system is based on a core belief that the future of agentic development will be multi-vendor. No single model, agent, or service will be right for every developer, team, or task.

From one product to an open system of products

This strategic shift has a practical consequence: JetBrains Air cannot be just another agent or development environment. It must connect products for individual work, team coordination, organizational control, context, and process automation – and remain open to the tools and agents developers choose, including those JetBrains does not build.

JetBrains Air includes products that are available today alongside others that will be introduced as the system develops:

• Air in JetBrains IDEs – a complete agentic development experience for directing and orchestrating agents and verifying their work inside JetBrains IDEs.
• Air Teams – a new way to coordinate and automate software-delivery workflows involving developers and autonomous agents.
• Air Governance (formerly JetBrains Central) – organizational policy, visibility, auditability, cost management, and accountability for AI-assisted and agent-driven development.

Junie is JetBrains’ coding agent for professional software development. It will be supported across all Air surfaces.

Air in JetBrains IDEs gives developers the environment to direct agents and verify their output using JetBrains’ code intelligence. Air Teams turns individual agent activity into coordinated team workflows. Air Governance makes that activity visible, governable, and accountable across the organization.

But an open system cannot stop at JetBrains’ own products. The Agent Client Protocol (ACP) standardizes the connection between an IDE and an agent’s full harness, including its planning, logic, tools, model routing, and observability. Through the ACP Registry, developers can discover and run a growing range of compatible agents while continuing to work inside JetBrains IDEs.

Air Governance is designed to extend visibility and cost governance across providers and the different tools through which agentic work takes place. This means developers can choose the agent, model, or service suited to the task without forcing the organization to give up context, visibility, or control.

Together, the Air products allow work to move between developers, agents, tools, and environments without losing the context and controls surrounding it.

Individual adoption has moved faster than organizational infrastructure

Since March, our products have progressed significantly, but so has our understanding of what agentic development requires.

Developers have been adopting agents faster than organizations can build the infrastructure around them. Agent capabilities have advanced, and different models and agents have proven useful for different tasks. However, the context, coordination, governance, and cost management surrounding them have not kept pace.

For many developers, agents are already delivering practical value. At the organizational level, the economics are much harder to prove. The costs surface elsewhere – in review, rework, security, infrastructure, and spend.

Which agents can access company code? Where can data go? Which output requires human review? What happened while an agent was working remotely? Who approved the resulting change, and how was it verified?

Fragmentation at this level isn’t just irritating. It makes software development harder to understand, measure, and govern at exactly the point when more of the work is being delegated.

The bottleneck is shifting with the work

Code that’s obviously wrong gets caught quickly. That part of the system still works. The harder problem is code that’s almost right: plausible, capable of passing a superficial check, but quietly carrying a bad assumption or architectural inconsistency that won’t surface until it’s expensive.

As agents take on more of the execution, the bottleneck shifts from producing change to understanding, verifying, and owning it. Code becomes cheaper to generate but more expensive to verify. Agent activity becomes easier to start but harder to coordinate, audit, and explain.

And while the work can be delegated, accountability cannot. An agent will not get the call at 3:00 am when something breaks. The responsibility for what ships still belongs to the people and organizations that ship it.

This is why control becomes harder, not easier, as AI improves. A more capable model may produce better output. It does not establish organizational policy, preserve provenance, provide cost visibility, or decide who accepts responsibility for the resulting change.

The future is multi-vendor

Multi-vendor support is a foundational design principle of JetBrains Air, shaping how the system is being built from the outset.

We don’t believe this market will consolidate any time soon. Models vary in what they’re good at, and rankings change every few months. Teams inside the same company already make different choices, and they are often right to do so. Standardizing on one AI vendor today means making a multi-year commitment in a market that won’t look the same next quarter.

Keeping the options open is the reasonable thing to do. The problem is what openness currently costs. Every new model, agent, or service an organization adds takes away a little more visibility into its own development work. Context doesn’t carry over between tools. Spend can’t be attributed. Policies have to be rebuilt for each service.

Organizations should not have to choose between using the best available tools and understanding what is happening inside their own engineering. That trade-off exists because nothing in the current stack was built to sit above several vendors at once.

This is the work JetBrains has taken on. We build our own agent, and we intend to make it excellent. But JetBrains Air does not require customers to use ours, and our strategy does not depend on which model provider leads the rankings this quarter. We have no reason to make the ecosystem smaller than it is.

What we can offer instead is one place to run, see, govern, and account for agentic development across every model, agent, and service – for the developer, the team, and the organization.

Supporting multiple models and agents is the floor, not the ceiling. The part that matters is what sits above them: shared context, one set of policies, a single cost view, and a record of what happened, regardless of which vendor produced the change.

Why JetBrains?

Multi-vendor choice solves only part of the problem. Agents also need reliable software intelligence.

JetBrains brings 26 years of engineering intelligence to the problem, helping developers understand the structure and behavior of complex software, not simply generate more of it. That deterministic code intelligence provides a foundation for making agentic work more reliable, efficient, and understandable across different models and agents. We are seeing promising results from giving AI agents access to deterministic code intelligence.

This is an economic advantage as well as a technical one. Agents spend time and money rediscovering information the codebase already contains. An agent that can retrieve that knowledge is cheaper and more accurate than one that has to reconstruct it. Because intelligence does not belong to one model, the benefit can extend across supported agents and services.

We are also going through the same transition as the organizations we build for, adopting agents internally, redesigning workflows, and learning where individual productivity gains translate into better software delivery and where they simply move work elsewhere.

What comes next

JetBrains Air will develop through a rolling series of releases. We will be explicit about what customers can use now, what is entering preview, and what remains part of our longer-term direction.

Over time, JetBrains Air will extend further into mobile and remote experiences, allowing people to initiate, monitor, review, and continue agentic work as it moves between environments. The goal is not to reproduce the IDE on every surface. We are making the right context and controls available wherever decisions need to be made.

We will also bring JetBrains’ intelligence into more agentic workflows. This includes richer context drawn from code, architecture, repositories, runtime behavior, and organizational knowledge, as well as better ways to route work between developers, models, agents, and services.

More work will be triggered by repository events, schedules, and delivery processes rather than by a developer opening an editor and issuing a prompt. JetBrains Air will provide the intelligence, oversight, and human control these workflows require across surfaces and services.

We will not name future products before their scope and availability are ready to be confirmed. With each release, we will explain what works, how it connects, and what’s still in progress.

Where JetBrains Air is going

The companies that succeed in adopting AI will not necessarily be those that generate the most code or deploy the most agents. They will be those that can expand experimentation without losing quality, context, cost discipline, or human understanding.

JetBrains Air is our commitment to building for that reality. It expands JetBrains from the developer workbench into a system of products connecting developers, agents, teams, and organizations.

The goal is not more code. It is software that developers, teams, and organizations can understand, verify, and stand behind.

Subscribe to JetBrains Blog updates