JetBrains Air
- As of this release, IntelliJ IDEA ships with Air, a new layer for agentic development. Work with the coding agents of your choice, and run, track, and verify multi-agent workflows inside your IDE, where code intelligence helps agents make fewer wrong turns and gives you the tools to review every change before it ships.
- Your agents, your models, your subscriptions – with Junie Lite for free
- Air works with Claude Agent, Codex, Gemini, GitHub Copilot, Junie, OpenCode, and other ACP-compatible agents. It detects the agents already installed on your machine so you can connect them in a click, and you can add more from the agent registry.
- Your existing setup carries over, too: provider subscriptions, API keys, and even a custom base URL all work, with no JetBrains AI subscription required. Run Claude Agent on your Claude subscription in the terminal or in a full-screen IDE tab, use other agent subscriptions in the chat or terminal, and switch between subscriptions at any moment, even mid-session.
- Air includes free AI with the Junie Lite configuration, so you can use an agent without a subscription. You only need a JetBrains Account.
- A central workspace to review changes and guide the agent
- Review an agent's changes with the surrounding code and your project tools in view, and send feedback straight back to the agent. Anchor a note to a specific line in the diff, or comment directly from the code, so the agent gets concrete context about the change you want. Work in the chat or the terminal, whichever suits you.
IntelliJ IDEA’s Java and Kotlin for Cursor and VS Code extension
- IntelliJ IDEA's Java and Kotlin intelligence now runs in VS Code, Cursor, Antigravity, and other compatible editors, giving you the IDE's code analysis, navigation, and refactorings through the Language Server Protocol. JetBrains worked with the Cursor team to deliver this, and the extension supports Cursor's Agents Window, so the agent and the person reading its changes share one source of truth for Java and Kotlin code.
Debugging improvements
- ij-debugger agent skill
- The ij-debugger skill grants AI agents direct access to the debug configurations, logpoints, and runtime diagnostics in your project, helping them identify the root causes of issues more accurately. Any debugger extensions installed in the IDE get wired into the agent through the skill.
- The update to this skill in 2026.3 makes agentic debugging even more reliable. Logpoint and process outputs remain fully accessible after a debugging session terminates, preserving critical evidence. Additionally, the skill accounts for execution context, avoiding dead breakpoints like closing braces and adjusting loop iteration counts to ensure accurate automated analysis.
- Hibernate debugger
- Gain total visibility into persistence layer execution with the new Hibernate debugger. Simply step over a repository call to view generated SQL and bound parameter values, along with the corresponding HQL or JPQL queries with direct links to the originating line of code.
- Streamline query optimization by replaying captured SQL or opening pre-filled HQL/JPQL queries. Flexible filtering options allow you to narrow output by transaction or execution duration so you can quickly spot suspected N+1 queries before they impact performance.
- Spring Security diagnostics in HTTP responses
- A 401, 403, or login redirect doesn't say which rule rejected the request. To make this information visible, Spring Debugger automatically injects a custom x-spring-debugger-security-decisions header into HTTP responses. This header delivers instant diagnostic context to you in your HTTP client or browser, as well as to your agents, identifying the exact filter chain, matched security rule, deciding filter, principal, and granted authorities.
- AppGlass
- Diagnose complex production issues safely and efficiently without downtime. The AppGlass Debugger plugin attaches to running environments, allowing you to inspect live execution data without redeploying or restarting the application or opening debug ports.
- You can set live tracepoints, capture non-intrusive runtime snapshots, and group execution traces by request. AI-assisted tracepoint suggestions and automated trace analysis can also help you pinpoint hard-to-reproduce bugs directly within IntelliJ IDEA.
Quick tasks and edits without opening a project
- Not every task needs a project. The new Home window replaces the Welcome screen, so you can get to work the moment IntelliJ IDEA opens. Edit a file, run a terminal command, or perform Git actions – all without waiting for a full project to load.
- Create a standalone file and start typing immediately, choosing its name and location when you save. Your recent projects and actions for opening or creating a project are available on the left whenever you need the full IDE.
Support for the latest technologies
- Java 28
- Explore the latest language features early, with the ability to download and configure Java 28 Early Access builds directly from the IDE settings.
- Jakarta Persistence 4 and Hibernate 8 support
- Run JPA and Hibernate console queries seamlessly in projects using Jakarta Persistence 4 or Hibernate 8. Calls to createNamedQuery and createNamedStatement on the new EntityHandler interface get completion and navigation to their declarations, including @NamedStatement and @NamedNativeStatement.
- Scala
- The Scala plugin now provides full support for Scala 3.10, along with improved code analysis and faster project imports for sbt 2.x projects.
- Kotlin support for Spring Modulith
- IntelliJ IDEA now parses Spring Modulith metadata declared on Kotlin types, such as @ApplicationModule and @NamedInterface, providing completion, navigation, automated inspections, quick-fixes, and refactorings in Kotlin.
Sound cues for IDE events and editor line marks
- Screen reader users now get audio cues for editor line marks: errors, warnings, VCS changes, and code folding. Builds, tests, and other long-running tasks play distinct sounds for success, warning, and error states, and breakpoint hits also trigger a sound.
- Agents in Air come with sound cues of their own, and they're enabled by default for everyone, whether or not you enable screen reader support. You'll hear when an agent finishes, stops with an error, or needs your input, as well as when dictation starts or stops. This is also handy if you work across several monitors or projects.
- Preview sounds on the new Accessibility settings page, or enable them for specific notification groups with the Play sound checkbox in the Notifications settings.
Git worktrees for parallel work and easy code reviews
- Agents and developers reviewing agent output benefit from isolating the agentic work into dedicated project instances. While Git worktrees cleanly isolate code revisions, an active development environment consists of much more than tracked source files.
- To make sure an environment created from a Git worktree is configured correctly, IntelliJ IDEA 2026.3 automatically duplicates your local project configuration into new worktrees, preserving run configurations and .idea settings without requiring you to commit them to version control. A .worktreeinclude file gives you granular control over what should and should not be copied, and a specific setup script can run to warm up the environment.
Agentic workflows
- Giving the right context to your agent is the key to getting good and effective results. In addition to code knowledge, IntelliJ IDEA 2026.3 gives your agents access to a wide variety of tools to get context from other sources such as Figma and Storybook.
- Figma design context in Air chats
- Send design context from Figma straight to an agent inside your IDE. Select any Figma layer and pass its hierarchy, spacing, and design variables directly to the chat, so that your agent knows exactly what the UI requires and can write better code.
- This workflow is available through Figma Connect, a new plugin for JetBrains IDEs.
- Storybook workflows in the IDE
- Install the Storybook Connect plugin to browse and search stories in a dedicated tool window, navigate between a story and its source code, and keep selections synchronized between Storybook and the IDE.
- Set up Storybook in one click and manage your local Storybook development server from the IDE. A bundled CLI and agent skills also support Storybook workflows in CI scripts and when working with AI agents.
- Chrome DevTools Connect
- Close the feedback loop between code and browser execution. The Chrome DevTools Connect plugin equips AI agents with the chrome-devtools-cli skill, allowing them to open web pages, inspect rendered DOM elements, analyze console logs and network requests, and automatically verify runtime UI fixes.
- Database-specific features in JetBrains Air
- When using Air to guide agents, you can run SQL queries directly within Air’s chat window, inspect CSV outputs in the built-in data editor, and resolve database object references with Quick Definition and code completion support that uses your IDE's native formatting rules.
Databases
- Cross-database queries
- When related data lives in different databases, comparing or joining it previously required copying data from one system into another first. That step is no longer needed. You can now query and join data across completely different DBMS targets without manually exporting records.
- Powered by an in-memory DuckDB engine, the new Workspace data source allows you to run SQL console queries referencing tables from multiple distinct database connections simultaneously.
- DuckDB support
- DuckDB is now supported as a first-class database target. This version offers full code completion, SQL dialect syntax highlighting, inspections, and schema introspection for DuckDB data sources.
- Quick database connections from containers and pods
- Connecting to database services inside Docker containers or Kubernetes pods no longer requires you to copy credentials manually. Selecting a running container extracts database credentials automatically, allowing you to establish a connection in one click.
- New Database Output tool window
- Query results get a dedicated home in this release. When you run a query, a run configuration, or an SQL file, results now appear in the new Database Output tool window, which opens automatically at the bottom of the IDE, taking over this role from Services.
Connect any language server from the IntelliJ IDEA settings
- Missing language support no longer has to be a blocker. IntelliJ IDEA lets you use any LSP server without writing a custom plugin.
Remote development directly from the IDE
- You can now work on remote projects directly from IntelliJ IDEA. A built-in SSH flow lets you connect to a host, start a development session, and reconnect to existing sessions, so your team has fewer separate tools to configure, maintain, and secure.
- On Linux backends, the new Light mode opens the project while the remote IDE is still downloading and launching. Editing, the terminal, and file search work right away, and the session switches to full mode automatically once the IDE is ready, preserving your work and state.
- SSH connections now use OpenSSH, improving compatibility with the authentication methods and tools your team already uses.
A more reliable terminal for your command-line tools
- AI agents and full-screen apps like Neovim and tmux rely on modern terminal protocols, and previously the built-in terminal didn’t support all of them.
- In 2026.3, JetBrains worked with the Ghostty team to fix that, and the terminal now runs on libghostty, the emulation library behind Ghostty. You get the compatibility of a modern standalone terminal, along with IDE features such as file links and command blocks.
Terminal tabs in the editor
- Give build logs, long command output, and terminal-based agents such as Claude Code more room next to your code. You can convert a terminal tab into an editor tab, even while a session is running, by dragging it into the editor or choosing Open as Editor Tab from its context menu.
- Once it’s in the editor, as with any tab, you can split it beside your source files, switch to it with the switcher, and rename it if you want. If a session is still running, the IDE warns you before you close its tab or restart it, so you don’t end a session by accident.
File navigation inside Kubernetes pods
- Stay in your flow without context switching to external terminals or CLI tools. IntelliJ IDEA now lets you browse, create, and edit files directly inside Kubernetes pods right from the IDE. Work with remote container files just like local ones, leveraging the full power of your familiar editor to inspect and troubleshoot workloads.
Performance and quality
- IntelliJ IDEA 2026.3 ships with over 1,000 bug fixes and more than 200 performance fixes.
- Remote development, WSL, debugging, Java and Kotlin language intelligence, and Spring Modulith and Spring Boot profiles received the most fixes.
Performance and stability improvements
With respect to performance, the focus areas for this release are freezes, CPU usage, and the effectiveness of code intelligence.
JetBrains removed UI freezes associated with Gradle and Maven sync, Spring Boot and JPA inspections and inlay hints, JSP and JSF indexing, the debugger, and the built-in spell checker. JetBrains also fixed a Kotlin K2 hang that occurred when working with deep type hierarchies, high CPU usage when opening large files and images, memory leaks that kept closed projects alive, and slow indexing and caches on large projects.
Automatic error and freeze reporting
To help identify the problems that interrupt your work and prioritize fixes based on their impact, IntelliJ IDEA 2026.3 automatically sends error and UI freeze reports to JetBrains.
Reports contain only technical data. Personal details such as file paths, URLs, and usernames are removed from report messages before they leave your machine.