Junie Merges Into JetBrains AI Chat: One Interface to Rule Them All

TL;DR

• JetBrains is merging Junie into the main AI chat interface, ending the two-UI split
• Junie is now available in beta directly from the AI chat agent selector
• The standalone Junie plugin will eventually be deprecated, but remains available during transition
• If you use JetBrains IDEs with AI tools, this consolidation matters — one less interface to context-switch between

The Big Picture

JetBrains shipped two separate chat interfaces for AI assistance: one for Junie, their coding agent, and another for general AI chat. It was confusing. Developers had to remember which interface did what, and context didn't carry between them.

Now they're fixing it. Junie is moving into the main AI chat as a selectable agent, and the standalone interface is on the way out. This is the first step toward a unified AI experience in JetBrains IDEs.

Why does this matter? Because fragmented UX is friction. Every extra click, every mental model you have to maintain, every time you wonder "wait, which chat do I need for this?" — that's cognitive overhead. JetBrains is acknowledging that the two-interface experiment didn't work, and they're consolidating before the split becomes permanent.

The beta is live now. Your existing Junie settings — model choices, Action Allowlist, MCP server configs — carry over. The standalone plugin isn't disappearing immediately, so you can transition at your own pace. But the writing is on the wall: one interface is the future.

How It Works

The technical implementation is straightforward. JetBrains built Junie as a selectable agent within the existing AI chat framework. When you open the AI chat, you'll see an agent selector. Pick Junie, run a prompt, and the agent downloads and installs automatically if you don't have it yet.

Under the hood, this is a merge of two parallel R&D tracks. When coding agents first emerged, JetBrains wasn't sure what the right UX pattern was. They built two separate interfaces to test different approaches. One focused on conversational AI assistance. The other, Junie, leaned into agentic workflows — multi-step tasks, file editing, terminal commands.

The industry has since converged on clearer patterns. Coding agents like Junie, Cursor, and Windsurf all follow similar interaction models: you give a high-level instruction, the agent proposes changes, you approve or reject. The conversational chat and the agentic interface don't need to be separate anymore.

During the transition period, settings are handled carefully but not perfectly. In this first iteration, Junie and the AI chat maintain separate settings. Changes you make in the AI chat won't affect Junie's standalone plugin. But changes in Junie's settings will apply to both the standalone plugin and the chat version. It's a temporary compromise to avoid breaking existing workflows while the merge completes.

Your Action Allowlist — the permissions you've granted Junie to edit files, run commands, or access APIs — persists. Your MCP server configurations stay intact. JetBrains is promising gradual migration, not a hard cutover that wipes your setup.

The architecture here is smart. Instead of forcing everyone onto the new interface immediately, JetBrains is running both in parallel. The standalone plugin remains available. You can keep using it while you test the chat-integrated version. When the unified interface reaches feature parity and stability, the standalone plugin will be deprecated. No timeline yet, but the direction is clear.

What This Changes For Developers

If you're already using Junie, this is a workflow shift. You'll need to retrain your muscle memory. Instead of opening the Junie panel, you'll open the AI chat and select Junie from the agent dropdown. It's a small change, but it's a change.

The upside: context continuity. Right now, if you're chatting with the AI assistant about an architecture decision and then want Junie to implement it, you have to switch interfaces and re-explain the context. With the unified interface, that context stays in the same conversation thread. You can go from discussion to implementation without repeating yourself.

For teams using multiple JetBrains AI features, this reduces cognitive load. One interface for all AI interactions means one set of keyboard shortcuts, one mental model, one place to check history. It's the same reason VS Code's extension model works — centralized UX beats fragmented tools.

The beta label matters. JetBrains says the chat-integrated Junie should be "on par" with the standalone plugin, but that's a hedge. Expect rough edges. Settings might not sync perfectly. Some features might behave differently. If you're in the middle of a critical project, maybe wait. If you're curious and can tolerate bugs, try it now and file feedback.

The transition period is also a signal. JetBrains is giving users time to adapt, which means they're not confident the new interface is a strict upgrade yet. They're testing in production, using the beta label as cover. That's fine — it's honest. But it means you should treat this as an opt-in experiment, not a stable release.

Try It Yourself

Getting started is simple. Open the AI chat in your JetBrains IDE. If you don't have it installed, follow the installation guide. Once the chat is open, look for the agent selector dropdown. Choose Junie. Run any prompt — something like "refactor this function to use async/await" or "add error handling to this API call." The agent will download and install automatically if it's not already present.

Test the context continuity. Start a conversation with the general AI assistant about a feature you're building. Then switch to Junie and ask it to implement part of that feature. See if the context carries over, or if you have to re-explain.

Check your settings. Open Junie's configuration in both the standalone plugin and the chat-integrated version. Make a change in one and see if it propagates to the other. Document what syncs and what doesn't — that's useful feedback for JetBrains.

The Bottom Line

Use the chat-integrated Junie if you're already comfortable with beta software and want to reduce interface fragmentation in your IDE. The unified experience is the future, and getting familiar with it now means less disruption later. Skip it if you're in the middle of a deadline or rely on Junie for production workflows — the standalone plugin isn't going anywhere yet, and the beta label is there for a reason.

The real opportunity here is for JetBrains to set a standard. If they nail the unified interface, they'll have a blueprint for integrating future AI tools without fragmenting the UX further. The risk is that they deprecate the standalone plugin before the chat-integrated version reaches feature parity, forcing users onto an incomplete product. Watch the beta closely. If it stalls or regresses, stick with the standalone plugin until JetBrains proves the migration is ready.

Source: Junie