Junie: JetBrains’ AI Coding Agent, After General Availability

TL;DR + what changed at GA

Junie is JetBrains’ AI coding agent: give it a task in words, and it plans, edits across files, runs your build and tests, drives the real IDE debugger, and opens a PR. The one idea that separates it from a chat panel is that it acts through the IDE’s own machinery, not a text approximation of it. General availability, in June 2026, turned that idea into a product teams could put on production code. The five things worth your attention:

• Plan Mode — the plan is a real, editable document you approve before any code is written.
• Agentic debugging — Junie sets breakpoints and inspects runtime state through the actual debugger, not log statements.
• Remote / async runs — start a long task on your laptop, check it from your phone.
• One engine over ACP — the same agent in the IDE chat, the Junie tool window, and the CLI.
• Any model — JetBrains-hosted Claude by default, or bring your own key, or a local model via Ollama / LiteLLM / LMStudio.

The catch, told plainly up front: Junie is credit-metered. Claude Code and Codex fold model usage into a flat subscription; Junie bills against a credit balance, and heavy agentic work drains it faster than newcomers expect. More on that in Gotchas & credits.

What Junie actually is

Most coding assistants read your repository as a pile of text and predict edits. Junie’s premise is different: the IDE already knows things about your project that no amount of text-reading recovers — the resolved symbol graph, the build configuration, which tests exist and how to run them, how to attach a debugger. Junie is built to call those capabilities as tools. JetBrains’ own framing on launch day was blunt about it.

Read that as a spec, not a slogan. “Plans, debugs with IDE tools, runs long tasks” is a list of the four capabilities GA shipped, and “uses any model you choose” is the architecture that makes the cost advice (“frontier model for planning, cheap one for implementation”) possible. Everything below is those claims, unpacked and checked.

What general availability added

In the beta, Junie could already plan multi-step tasks, edit across files, and run tests. GA hardened it into something you would hand a production repo. The named pieces, each covered in its own section below:

One honest caveat before the details: JetBrains’ GA announcement was written by Dmitry Savelev and dated June 17, 2026, with the wider social rollout on June 23. Treat the exact day as “mid-June 2026” and the capabilities, not the calendar, as the story.

Install Junie (IDE and CLI)

Junie is not an MCP server — it’s the agent, and it can be an MCP client (see Junie + MCP). So there is no npx server line to paste into a client config. You install Junie itself, two ways.

In a JetBrains IDE

Junie ships bundled in the current JetBrains IDE family — IntelliJ IDEA, PyCharm, WebStorm, GoLand, Rider, RubyMine, CLion, PhpStorm. Open the Junie tool window from the right sidebar. If your IDE predates the bundle, install Junie from Settings → Plugins (the JetBrains Marketplace). You sign in with a JetBrains Account; the AI Free tier is enough to try it, with a small monthly cloud-credit quota.

The Junie CLI (terminal, CI/CD)

GA also shipped a standalone terminal agent. Install it with the official script, npm, or Homebrew:

# macOS / Linux
curl -fsSL https://junie.jetbrains.com/install.sh | bash

# Windows (PowerShell)
powershell -NoProfile -ExecutionPolicy Bypass -Command "iex (irm 'https://junie.jetbrains.com/install.ps1')"

# npm (any OS)
npm install -g @jetbrains/junie

# Homebrew
brew tap jetbrains-junie/junie && brew install junie

Then run it from a project root:

cd /path/to/your/project
junie
# then: authenticate (JetBrains Account, JUNIE_API_KEY, or your own model key)
# > give me an overview of this codebase

Authentication is one of three paths: a JetBrains Account over OAuth, a JUNIE_API_KEY token from the Junie tokens page, or bring-your-own-key for a third-party model provider. For CI, run it headless with a single prompt:

junie --auth="$JUNIE_API_KEY" "Review and fix any code quality issues in the latest commit"

Inside the CLI, slash commands map to the same features: /plan, /model, /remote, /review, /mcp, and /install-github-action. The --acp flag exposes the agent to any ACP-speaking editor.

Plan Mode: the plan is an artifact, not a chat message

A lot of “planning” in agents is a paragraph the model writes and then ignores. Junie’s Plan Mode makes the plan a first-class document. In JetBrains’ words, plans are “presented as structured documents with tabs for product requirements, technical design, delivery stages, and (when requested) testing strategy.” You read it, edit it directly in the editor, and approve it — and only then does Junie implement.

Why this matters more than it sounds: the approval gate is where you catch a wrong assumption for the price of reading a page, instead of the price of reviewing a wrong diff. Start any task you can’t fully specify in one sentence with --plan (or the /plan command), correct the plan, then let it build. The plan doc is the cheapest place to be wrong; spend your attention there.

Agentic debugging: the real headline of GA

This is the capability that separates Junie from the pack. JetBrains puts it directly: “When Junie runs into a problem, it uses a real IDE debugger, not just log statements. If you have a JetBrains IDE with an AI subscription, Junie can start or join a debug session, set breakpoints in your code or its dependencies, and inspect the runtime state.”

Concretely: instead of adding print lines, re-running, and pattern-matching stdout, the agent attaches the debugger, sets a breakpoint (including inside a library on your classpath), steps execution, evaluates expressions in the live stack frame, and reasons over what it observed. That is a qualitatively different loop — it closes on the actual runtime, not a guess about it.

The fine print you must know: agentic debugging relies on a bundled Debugger MCP Toolset, which needs IntelliJ IDEA 2026.1.1 or newer, and the richest debugger tooling lives in the Ultimate edition. If your IDE or edition is older, this is the feature you won’t get. Debugging is where Junie earns its price; it’s also the most version- and edition-gated feature it has.

Remote runs and project-aware code review

Two GA features share a theme: taking the agent out of the “watch it type” loop.

Remote / async runs. JetBrains’ pitch: “Start a task from your laptop. Check progress from your phone during a meeting. Review the PR over coffee. Junie runs asynchronously and keeps the session available from anywhere you sign in.” The practical unlock is that a long refactor or test-writing job no longer pins your editor — you fire it and walk away.

Code review with context. Junie reviews, per JetBrains, “with the same project context it uses to write code: your build, your tests, your conventions, your past decisions.” That’s the difference between a linter and a reviewer — it can see whether a change fits how your codebase already does things. Three entry points: GitHub Actions, GitLab (including on-prem), or the /review command in the CLI or the plugin. A reviewer that knows your conventions is worth more than one that only knows the diff.

One engine over ACP, and any model you bring

GA rebuilt Junie’s IDE integration on the Agent Client Protocol (ACP) — the open standard JetBrains co-developed with Zed to let any editor talk to any agent, the way LSP unbundled language intelligence from editors. The payoff JetBrains describes is “one engine, many surfaces”: the same agent runs in the IDE chat, the Junie tool window, and the CLI, with shared context semantics. In the IDE, Junie over ACP “has access to IDE tools such as the semantic index, build configurations, and test runners.”

(Naming note: JetBrains’ GA post expands ACP as “Agent Communication Protocol”; the protocol it co-developed with Zed is officially the Agent Client Protocol. Same ACP.) For the full picture of how ACP and MCP are different layers that run together, see our Agent Client Protocol vs MCP explainer — short version: ACP connects the editor to the agent, MCP connects the agent to its tools.

Bring your own model. Default is Claude via a JetBrains AI subscription, but Junie is model-agnostic: bring-your-own-key for Anthropic, OpenAI, Google, xAI, OpenRouter, or Copilot, or point it at a local runtime. JetBrains: “Junie connects to local model runtimes — point it at LiteLLM, LMStudio, Ollama and the agent runs using whatever model you have loaded on your own machine.” That local path is the one that makes Junie viable where code can’t leave the building. Model choice isn’t a toggle for its own sake — it’s how you control both cost and data residency.

Junie + MCP

Because this is MCP.Directory, the question we care about: does Junie speak the Model Context Protocol? Yes, both ways.

Junie as an MCP client. You extend Junie with MCP servers — databases, browsers, SaaS APIs, search — through an mcp.json file, using the same mcpServers shape as Claude Desktop and Cursor. Two scopes: .junie/mcp/mcp.json at the project root (checked into version control, shared with the team) or ~/.junie/mcp/mcp.json for your user account. The IDE plugin and the CLI read the same config, and a /mcp command manages servers.

{
  "mcpServers": {
    "ServerName": {
      "command": "npx",
      "args": ["-y", "@package/name"],
      "env": { "ENV_VAR": "value" }
    },
    "RemoteServer": {
      "url": "https://mcp.example.com/v1",
      "headers": { "Authorization": "Bearer token" }
    }
  }
}

The IDE as an MCP server. Separately, JetBrains IDEs since 2025.2 ship an integrated MCP server, so external clients — Claude Desktop, Cursor, Codex, VS Code — can call IDE tools. Junie’s own agentic debugging rides the same machinery via the bundled Debugger MCP Toolset. So MCP isn’t bolted on; it’s how the IDE exposes its tools to agents, including Junie itself. New to the protocol? Start with What is MCP, then browse the server catalog for things to plug into that mcp.json.

The SWE-Rebench number, in context

JetBrains leads with a benchmark, and it deserves a careful read rather than a copy-paste. Per JetBrains, on the SWE-Rebench run at launch, “Junie came out as the top model-harness, with 61.6% resolved and a 72.7% pass@5.” That specific quote is credited to Alexander Golubev, Research Lead at Nebius, the team that runs the benchmark.

What that means, and what it doesn’t. SWE-Rebench (by Nebius) mines fresh, real GitHub issues on a rolling basis and tracks contamination against model release dates, so it resists the “trained on the test set” problem that plagues static benchmarks. It evaluates a model-harness — the model plus the agent scaffolding around it — which is exactly what Junie is. Two honest caveats: JetBrains is quoting a benchmark that flatters its own product, and, as JetBrains itself notes, “SWE-Rebench draws fresh tasks each cycle… so results move from run to run.” Treat 61.6% / 72.7% as a strong snapshot, not a permanent ranking — check the live swe-rebench.com leaderboard for where it sits today.

Junie vs Cursor vs Claude Code

The three get compared constantly; they’re actually different shapes.

The decisive axis for most people is the last row. Junie’s technical edge is the IDE integration; its practical friction is the credit meter. If you want a terminal agent on a predictable flat bill, read Claude Code and our Goose vs Cline vs Aider vs Claude Code vs OpenCode roundup. If what you actually want is fast autocomplete rather than a full agent, that’s a different category — see Cursor Tab vs Copilot vs Codeium vs Tabnine vs Cody.

What we got wrong about Junie

Three assumptions we walked in with, and where they broke:

• “It’s locked to JetBrains’ own model.” Wrong at GA. Junie is model-agnostic: bring your own Anthropic / OpenAI / Google / xAI / OpenRouter key, or run a local model via Ollama, LiteLLM, or LMStudio. The default is JetBrains-hosted Claude, but nothing forces it.
• “It’s an IDE-only feature.” Also wrong. There’s a full standalone CLI that installs with a curl script, npm, or Homebrew, runs headless in CI, and hooks GitHub Actions and GitLab. The IDE is one surface, not the only one.
• “‘Agentic debugging’ is marketing for reading logs.” No — it drives the actual debugger: sets breakpoints (including in dependencies), steps execution, evaluates expressions in the live frame. That’s the one feature we under-rated most.

Gotchas & the credit trap

• Credits drain faster than a flat sub. This is the loudest complaint in the community, and the root cause is structural, not a bug. As one r/Jetbrains user put it, credits “drain incredibly fast. Much faster than you’d experience with Claude Code or Codex. And that’s simply because Anthropic and OpenAI heavily subsidize their offerings through their monthly subscriptions.” If your mental benchmark is a $20 flat sub, Junie’s metered model will feel expensive on heavy days.
• Model choice changes reliability, not just cost. A cheap fast model (Gemini Flash) is great for grunt work and weak on complex plans. One user reported Junie on Gemini Flash “generated a benchmark with Math.sqrt(100) === 10” instead of a real one. Follow JetBrains’ own advice: frontier model for planning, cheap model for implementation.
• Agentic debugging is version- and edition-gated. It needs the bundled Debugger MCP Toolset (IntelliJ IDEA 2026.1.1+), and the deepest debugger tools are Ultimate-only. On older or Community setups, that headline feature simply isn’t there.
• ACP naming will confuse you. JetBrains’ GA post writes “Agent Communication Protocol”; the co-developed-with-Zed standard is the Agent Client Protocol. It’s the same ACP — don’t go hunting for two protocols.

Who Junie is for (and who it isn’t)

Community signal

The developer reaction is warmer on capability than on price. On r/Jetbrains, one user’s pattern captures the pragmatic take: “I like Junie (with Gemini Flash) because in my use cases, it’s almost twice as fast as Claude Code. Therefore, I use Junie until my credits are depleted, and then I switch to Claude Code with a subscription.” Speed and IDE integration pull people in; the credit ceiling pushes them back out.

The contrarian read is sharper. A two-month feedback thread (upvoted well past its critics) argued Junie “currently feels like… a half-finished solution,” describing credits “disappearing incredibly fast” and a cheap model producing a nonsense benchmark instead of the requested implementation — the user downgraded and moved day-to-day work to a cheaper API-billed agent. On Hacker News, the recurring pro-Junie point is the opposite of hype: it can hand the model “a textual API to the IDE’s static analysis database,” which is a real, structural advantage no text-only agent has. Both things are true at once — the integration is genuinely differentiated, and the billing model is the friction.

The verdict

Frequently asked questions

Glossary

Junie

JetBrains' AI coding agent; runs in JetBrains IDEs and as a CLI.

Agentic debugging

The agent driving the real IDE debugger — breakpoints, stepping, runtime state.

Plan Mode

A structured, editable plan document you approve before code is written.

ACP

Agent Client Protocol — the editor-to-agent standard JetBrains co-developed with Zed.

MCP

Model Context Protocol — the agent-to-tools standard Junie uses as a client.

BYOK

Bring Your Own Key — using your own Anthropic/OpenAI/Google/etc. model key.

SWE-Rebench

Nebius' rolling, decontaminated agent benchmark built from fresh GitHub issues.

pass@5

Share of tasks solved within five attempts; resolved rate is best pass@1.

Junie CLI

The standalone terminal agent, installable via script, npm, or Homebrew.

Debugger MCP Toolset

Bundled plugin exposing debugger tools over MCP; needs IntelliJ IDEA 2026.1.1+.

Credit

The metered unit JetBrains AI bills cloud model usage against.

Headless mode

Running the CLI non-interactively with one prompt, for CI/CD.

Sources

• Primary — GA announcement (Dmitry Savelev, June 17 2026): “The JetBrains AI Coding Agent moves to general availability”
• Primary — product + CLI docs: junie.jetbrains.com · Junie CLI MCP configuration · JetBrains/junie (npm @jetbrains/junie)
• Primary — ACP background: JetBrains ACP · Zed: “ACP Brings JetBrains on Board” (Oct 6 2025)
• Primary — benchmark: SWE-Rebench leaderboard · Nebius: introducing SWE-rebench
• Community — first-party GA thread: @jetbrains, June 23 2026
• Community — r/Jetbrains reactions: “My feedback after 2 months” · “Are you using Junie…?”
• Related on MCP.Directory: ACP vs MCP · Terminal coding agents compared · What is MCP