JetBrains Junie: AI Coding Agent That Solves 53.6% of Real Tasks

TL;DR

• JetBrains launched Junie, an AI coding agent that runs inside IntelliJ IDEA Ultimate and PyCharm Professional
• Scores 53.6% on SWEBench Verified, a benchmark of 500 real developer tasks
• Combines IDE context with LLMs to generate code, run inspections, write tests, and verify results
• Early Access Program waitlist is open — macOS and Linux only for now, WebStorm coming next

The Big Picture

JetBrains just entered the AI coding agent race with Junie, and they're taking a different approach than Cursor or GitHub Copilot. Instead of building a new editor or bolting AI onto an existing one, they're embedding an autonomous agent directly into the IDEs millions of developers already use.

The pitch is simple: delegate routine tasks entirely, or collaborate with Junie on complex ones. The agent doesn't just autocomplete — it executes multi-step workflows, runs tests, and verifies its own work using the same inspection tools you'd use manually. JetBrains claims Junie solves 53.6% of tasks on SWEBench Verified, a curated benchmark of 500 real-world developer issues. That's competitive with standalone agents, but with the advantage of native IDE integration.

This isn't JetBrains' first AI product. They've shipped AI-assisted features before, and they've even launched a free course on building AI agents. Junie is the logical next step: a full coding agent that leverages the deep project context their IDEs already have. If you've ever wished Copilot could refactor an entire module or write integration tests without hand-holding, Junie is aiming to do exactly that.

How It Works

Junie runs as a plugin inside IntelliJ IDEA Ultimate and PyCharm Professional. You install it, give it a task, and it uses the IDE's APIs to navigate your codebase, generate code, run inspections, write tests, and execute commands. The agent has access to the same project structure, dependencies, and tooling you do — no context-switching required.

The architecture combines LLMs with JetBrains' existing code intelligence. When you ask Junie to implement a feature, it doesn't just generate a code snippet and call it done. It can run the IDE's built-in inspections to catch errors, write unit tests to verify behavior, and execute those tests to confirm they pass. This feedback loop is what separates Junie from simpler autocomplete tools.

JetBrains is positioning Junie as a coding partner, not a black box. You can review every change the agent proposes and see how it executes commands. The agent is designed to understand project context and adapt to your coding style. You can also provide specific coding guidelines, which Junie will follow when generating code. This is critical for teams with strict style guides or legacy codebases where consistency matters more than speed.

The 53.6% success rate on SWEBench Verified is worth unpacking. SWEBench is a benchmark of real GitHub issues from popular open-source projects. Each task requires understanding a codebase, identifying the problem, writing a fix, and passing existing tests. A 53.6% solve rate on a single run means Junie can handle more than half of these tasks autonomously, without human intervention. That's not perfect, but it's high enough to be useful for real work.

JetBrains hasn't disclosed which LLMs Junie uses, but they emphasize "reliable LLMs" plural. It's likely they're using a mix of models depending on the task — smaller models for code completion, larger ones for complex reasoning. The IDE integration is the real differentiator here. Junie has access to your project's type information, dependency graph, and test suite, which gives it more context than a standalone agent working from raw text files.

What This Changes For Developers

If Junie works as advertised, it shifts the bottleneck in software development. Instead of spending hours writing boilerplate, refactoring legacy code, or adding test coverage, you delegate those tasks to the agent and focus on architecture, design, and the problems that actually require human judgment.

The workflow looks like this: you describe a task in natural language, Junie breaks it down into steps, executes them, and shows you the result. For simple tasks — adding a new API endpoint, writing a data migration, generating test cases — you review and merge. For complex tasks, you collaborate: Junie handles the grunt work, you guide the critical decisions.

This is different from Copilot's inline suggestions or Cursor's chat-based edits. Junie is designed to operate autonomously for longer stretches. You're not babysitting every line of code. You're delegating entire features or refactors and reviewing the output when it's done. That's a bigger shift in workflow, and it requires more trust in the agent.

The control mechanisms matter here. You can see how Junie executes commands, review proposed changes before they're applied, and maintain project context throughout. JetBrains is betting that developers will accept more autonomy if they have visibility and veto power. That's a reasonable bet, but it also means Junie needs to be right often enough that reviewing its work is faster than doing it yourself.

For teams, Junie could standardize code quality. If the agent follows your style guide and runs inspections on every change, you get more consistent output than you'd get from a team of developers with varying skill levels. That's valuable for large codebases or distributed teams where code review is already a bottleneck.

Try It Yourself

Junie is in Early Access, and you need to join the waitlist to try it. It's currently available for IntelliJ IDEA Ultimate and PyCharm Professional on macOS and Linux. WebStorm support is coming next. Windows support isn't mentioned, which is a notable gap.

JetBrains hasn't published code examples or API documentation yet, so there's no runnable demo to share. If you want to understand the broader context of how AI coding agents work under the hood, check out this deep-dive on AI coding agent architecture.

To get access, visit the Junie waitlist page and sign up. JetBrains is collecting feedback from early users, so if you get in, your input will shape the product.

The Bottom Line

Use Junie if you're already a JetBrains IDE user and you want an agent that understands your project without leaving your editor. The 53.6% SWEBench score suggests it can handle real tasks, not just toy examples. The IDE integration is the killer feature here — Junie has access to type information, dependency graphs, and test suites that standalone agents don't.

Skip it if you're on Windows, using a different IDE, or working in a language that isn't well-supported by IntelliJ or PyCharm. The Early Access limitations are real, and there's no timeline for broader availability. If you need an agent today and you're not in the JetBrains ecosystem, Cursor or Aider are more accessible options.

The real risk is whether JetBrains can maintain the quality bar as Junie scales beyond the benchmark. A 53.6% solve rate is impressive, but it also means the agent fails nearly half the time. If reviewing Junie's work takes longer than doing it yourself, the productivity gains evaporate. The opportunity is huge if they get it right: millions of developers already trust JetBrains IDEs, and an agent that works seamlessly inside those tools could become the default way people write code.

Source: Junie