JetBrains Junie Roadmap: Smart, Controllable AI Coding Agent

TL;DR

• JetBrains is building Junie to optimize end-to-end development speed, not just code generation velocity
• New Plan feature provides transparent reasoning and stop-continue control to avoid black-box AI frustration
• Automatic model selection uses benchmarks to pick the best AI for each task — Junie hit 60.8% on SWEBench
• Developers who want transparency and control over their AI agent, not a turn-based guessing game

The Big Picture

JetBrains is making a bet that most coding agents are solving the wrong problem. The industry obsesses over how fast an AI can spit out lines of code. JetBrains thinks that's missing the point.

The real metric is end-to-end velocity: from idea to merged code to deployed feature. That's the thesis behind Junie's roadmap, and it's why the team is investing in workflow orchestration, not just better autocomplete.

This isn't a changelog. It's a vision document. JetBrains published their priorities for Junie after months of internal use and early access feedback. The focus is clear: build an agent that developers actually want to collaborate with, not one that forces you into a frustrating loop of generate-review-reject-repeat.

The subtext here is important. JetBrains is positioning Junie against tools like traditional AI coding agents that treat developers as passive reviewers. Their pitch: you should understand what the agent is doing, control it in real time, and trust it to make decisions without babysitting every line.

How It Works

Junie's architecture revolves around transparency and control. The centerpiece is the Plan feature, which shows you the agent's reasoning before it executes. You see the high-level strategy and the specific steps. If you don't like the direction, you stop it, add guidance, and continue. No wasted cycles on code you'll throw away.

The workflow breaks into five stages. First, task formulation: Ask mode lets you brainstorm, discuss ideas, and refine requirements before Junie writes a single line. Second, planning and control: the two-column interface shows reasoning on one side, execution on the other. Third, code review: Code mode and Ask mode work together so you can iterate on changes without context-switching. Fourth, terminal integration: Junie can run scripts, read logs, and deploy. You choose between manual approval mode or brave mode for autonomous execution. Fifth, quality assurance: the agent is optimized to reduce the probability you'll discard generated code or inherit technical debt.

The model selection strategy is unusual. JetBrains isn't locking Junie to a single LLM. They're testing multiple models against real coding benchmarks and user feedback, then automatically routing tasks to whichever model performs best. The philosophy: it's their job to figure out which AI to use, not yours. They're building an advanced mode for manual model selection and custom endpoints, but the default behavior is automatic gear-shifting.

Customization happens through .junie/guidelines.md files and upcoming configurable settings. You'll be able to adjust dials for creativity, risk tolerance, and coding style strictness. Some settings are guideline-based, others are deterministic — like always running tests before submitting. JetBrains is also working on scaling Junie to handle tasks with hundreds of files and steps by breaking large tasks into smaller ones and executing them in parallel.

The benchmark progress tells the technical story. A year ago, Junie scored 20% on SWEBench. By January, 53%. Today, 60.8% — one of the highest in the industry. SWEBench measures how well an AI produces correct code for real-world tasks, so this isn't a toy metric. It's a proxy for trust.

What This Changes For Developers

The immediate impact is workflow compression. If Junie's Plan feature works as advertised, you spend less time deciphering what the agent did and more time deciding whether the approach is right. That's the difference between reviewing code and reviewing strategy.

The stop-continue model is the key innovation here. Most agents force you into a turn-based game: the AI makes a move, you spend 10 minutes reading code, you comment or roll back, the AI continues. JetBrains is betting that real-time steering and transparent planning eliminate that friction. You're not playing chess with an opaque opponent. You're pair programming with a collaborator who explains their thinking.

The terminal integration changes the scope of what you can delegate. If Junie can run scripts, read logs, and deploy, it's not just a code generator — it's a workflow automator. The manual approval mode gives you a safety net. Brave mode lets you go fully autonomous. The risk is obvious: autonomous execution can break things. The opportunity is equally obvious: you stop doing repetitive deployment tasks and focus on architecture.

The pricing model matters more than it should. JetBrains introduced two tiers: AI Pro for occasional use, AI Ultimate for heavy users. The goal is worry-free pricing — no token counting, no run limits. But Pro users are hitting quota limits faster than expected, and JetBrains admits they need to optimize context usage and improve transparency. If you're evaluating Junie, budget for Ultimate if you plan to use it daily.

The customization angle is underrated. Every team has opinions about how aggressive an AI agent should be. Some want conservative, high-confidence changes. Others want creative, exploratory suggestions. The .junie/guidelines.md approach lets you encode those preferences. The upcoming configurable settings will make it easier, but the guideline file is available now and worth using.

Try It Yourself

Junie is available as part of JetBrains AI Pro and AI Ultimate subscriptions. You can access it through JetBrains IDEs that support the AI Assistant plugin. For hands-on learning, JetBrains offers a free AI agents course that covers architecture and implementation patterns.

To get started, install the JetBrains AI Assistant plugin in your IDE, enable Junie, and create a .junie/guidelines.md file in your project root. Use it to define coding standards, preferred libraries, and risk tolerance. Start with small tasks — refactoring a function, adding a feature to a single file — and observe how the Plan feature structures the work. Experiment with stop-continue mode to see how well you can steer the agent mid-task.

The Bottom Line

Use Junie if you're already in the JetBrains ecosystem and you want an agent that prioritizes transparency over speed. The Plan feature and stop-continue model are real differentiators if you've been frustrated by black-box AI tools. The 60.8% SWEBench score suggests the code quality is competitive with the best agents available.

Skip it if you're not a JetBrains user or if you need an agent that works outside the IDE. The terminal integration is promising, but it's still maturing. Brave mode improvements are coming, but if you need granular control over autonomous execution today, you'll be waiting for future releases.

The real risk is pricing confusion. Pro users are hitting limits faster than expected, and JetBrains is still optimizing context usage. If you're committing to Junie, plan for Ultimate tier costs. The real opportunity is workflow compression: if the Plan feature delivers on its promise, you'll spend less time reviewing code and more time making architectural decisions. That's the shift JetBrains is betting on, and it's the right problem to solve.

Source: Junie