Junie
JetBrains · Junie: JetBrains' Model-Agnostic AI Coding Agent for the Terminal, JetBrains IDEs, GitHub, and GitLab
Junie is JetBrains' AI coding agent. It plans, writes, tests, debugs, and reviews code from a CLI, inside JetBrains IDEs and Android Studio, and from GitHub or GitLab issues and pull requests. It works with JetBrains AI credits, your own model API keys, or local models, which suits developers who live in IntelliJ-based IDEs and want to choose the model each task runs on.
Best for
Developers and teams who work in IntelliJ-based IDEs or Android Studio and want a coding agent that uses the IDE's debugger, test runners, and code index, with the freedom to switch between JetBrains credits, their own API keys, and local models
Not ideal for
VS Code or Neovim users who would not use the IDE integration, teams that require an open-source agent, and heavy users of frontier models who want a flat-rate plan rather than credits or per-token billing
Who it's for
Professional developers and engineering teams using JetBrains IDEs or Android Studio, plus terminal and CI users who want a model-agnostic coding agent
Capabilities
- One agent across Junie CLI, the AI Chat and Junie tool window in JetBrains IDEs and Android Studio, a GitHub Action, and GitLab CI/CD
- Advanced Plan mode writes requirements, technical design, delivery stages, and optional testing strategy to `.junie/plans` for you to edit, commit, and approve before implementation
- Agentic debugging in JetBrains IDEs: starts or joins debug sessions, sets breakpoints in project, library, SDK, and decompiled code, and inspects stack frames and expressions
- Uses the IDE's semantic index, build configurations, test runners, and databases configured through DataGrip or the Database plugin
- Bring your own key for OpenAI, Anthropic, Google, xAI, OpenRouter, GitHub Copilot, or LiteLLM, plus custom model profiles and local runtimes such as Ollama and LM Studio
- Junie Local runs a tuned Qwen-based model on your machine through the `/local` command, with no cloud calls or AI credits
- `/review` for unstaged, staged, or branch diffs, automated pull request reviews with inline comments on GitHub, and automatic reviews of newly opened GitLab merge requests
- GitHub Action that runs on your own runners and turns `@junie-agent` mentions, labels, or assignments into pull requests, CI fixes, or merge-conflict resolution
- GitLab CI/CD integration for GitLab.com and self-managed GitLab, triggered by `#junie` in issues and merge requests
- `/demo` builds and launches your app in a Docker environment, drives its UI with a computer-use model, and returns a video, screenshots, and an HTML report
- Live prompting to steer a running task, an action allowlist with per-command approval, conversation branching with `/branch`, and live session cost in the CLI
- Remote mode (`/remote`) to keep a CLI session running on your machine and follow or steer it from a browser on another device
- Project guidelines, Agent Skills, shared slash commands, and MCP servers
Limitations
- Debugger, database, and deep IDE integrations need a JetBrains IDE; JetBrains says agentic debugging works end to end in JetBrains IDEs with an AI subscription
- Cloud usage through JetBrains AI is metered in AI credits (1 credit = $1). AI Pro includes 10 credits and AI Ultimate 35 credits per 30 days for individuals, so frequent agent work on frontier models may need top-ups or your own API keys
- Junie Local currently requires macOS 26 or later on an Apple Silicon M5 or newer Mac with 64 GB of RAM and about 21 GB of free disk, and JetBrains' docs list the `/local` command under nightly builds; Windows support for NVIDIA RTX cards (Ampere or newer, 24 GB VRAM) is experimental and only in nightly builds
- Junie is proprietary. The public GitHub repository holds installers, release channels, and templates under an all-rights-reserved license, not the agent's source code
- Remote mode needs a JetBrains account sign-in or a Junie API key (BYOK alone is not enough), is not available when signed in through JetBrains AI Enterprise, and stops responding if the host machine goes to sleep
- With BYOK, Junie still calls a second model from the same provider for internal tasks such as summarizing context and routing, so you may see calls to models you did not select
- The AI Free tier is not available in Android Studio or in the free Community editions of IntelliJ IDEA and PyCharm, and JetBrains AI is limited to supported territories
- Setting up the GitLab integration needs a separate pipeline project, access tokens with Maintainer or Owner roles, and per-project initialization
Use cases
- Planning a Spring Boot or Java version upgrade as an editable plan, then letting Junie implement it and monitoring it remotely
- Asking Junie to debug a flaky test with the IDE's debugger and report why a value becomes null
- Turning a GitHub issue into a pull request by mentioning `@junie-agent`, or fixing a failing CI build from the workflow
- Running automated reviews on every merge request in a self-managed GitLab instance
- Recording a `/demo` video of a new UI flow for reviewers before merging
- Working on proprietary code with Junie Local or a local Ollama model so prompts and code stay on the machine
Our take
Junie's case rests on two things most coding agents do not have: the JetBrains IDE as a toolbox and real model choice. Inside IntelliJ-based IDEs it can debug with breakpoints and inspect runtime state, use the IDE's index and test runners, and query your databases, and plans are committed files rather than chat messages. Being able to plan on a frontier model, implement on a cheap one, bring your own keys, or go fully local makes cost something you control. The catches are that the IDE-specific advantages disappear for VS Code users, the credit quotas on JetBrains AI plans are modest for heavy agent use, and Junie Local's hardware bar is high for now. JetBrains shops should try it before reaching for an editor-agnostic agent, and everyone else should compare it on a real task.
Who should use it
Teams standardized on IntelliJ IDEA, PyCharm, WebStorm, GoLand, Rider, or Android Studio, developers who want one agent across the terminal, IDE, and GitHub or GitLab CI, and organizations that need to pick or mix model providers, including local models for sensitive code.
Who should skip it
Developers who work only in VS Code, Neovim, or Zed, teams that require an open-source agent they can audit and modify, and heavy agent users who want a predictable flat-rate plan.
Strengths
- Uses the IDE's real debugger, test runners, code index, and databases instead of approximating them
- Model-agnostic: JetBrains credits, your own keys, or local models, chosen per task
- Plans are real files you can edit and commit before any code changes
- Same agent in the terminal, the IDE, GitHub, and GitLab, including self-managed GitLab
- Free start with BYOK at provider rates and a fully local option
Weaknesses
- The best features depend on a JetBrains IDE and AI subscription
- Credit quotas on AI Pro and AI Ultimate are small for heavy frontier-model use
- Junie Local needs very recent, high-memory Apple Silicon hardware
- Closed source: the GitHub repository has installers and templates, not the agent's code
Junie pricing
Free
$0
- 5 AI credits to start, per Junie's pricing section; JetBrains' licensing docs list AI Free at 3 AI credits per 30 days
- Bring your own key at provider rates with no markup
- Local models and Junie Local supported
AI Pro (individual)
$10/month
Billed monthly
- 10 AI credits per 30 days
- Top-ups anytime
- $8.33/month billed annually
- Organizations: $20/user/month with 20 AI credits
AI Ultimate (individual)
$30/month
Billed monthly
- 35 AI credits per 30 days
- Recommended by JetBrains for regular Junie use
- $25/month billed annually
- Organizations: $60/user/month with 70 AI credits
AI Enterprise
$60/user/month
Billed monthly
- Organizations only, as part of JetBrains IDE Services
- Credit quota on par with AI Ultimate or higher
- Top-ups not yet available
Free tier limits: Junie's pricing section says the free start includes 5 AI credits and needs no card or subscription; it does not say whether those credits renew. JetBrains' licensing docs list the AI Free tier at 3 AI credits per 30 days, and AI Free is not available in Android Studio or the free Community editions of IntelliJ IDEA and PyCharm. With your own API keys or local models, credits are not needed.
Note: Junie's cloud usage is billed through JetBrains AI subscriptions. One AI credit equals $1, quotas renew every 30 days, and Top-up AI Credits are valid for 12 months. A 30-day AI Pro trial (10 AI credits for individuals) can be started from the IDE and may ask you to link a credit card. Organizations migrated to JetBrains Central (now Air Governance) share a pooled credit balance. BYOK usage is billed by your model provider, and BYOK keys take priority over JetBrains credits when both can serve a model.
Technical specs
Available models
Where Junie excels
Diagnosing a bug that only appears at runtime
Instead of adding print statements, Junie can launch the test under the IDE debugger, set breakpoints in project or library code, and inspect stack frames and expressions, then report what actually happened.
Running a framework upgrade as a reviewed plan
Advanced Plan mode writes requirements, design, and delivery stages to `.junie/plans`, where the team can edit and commit them. Junie then implements the approved plan, optionally on a cheaper model, while you check progress remotely.
Delegating fixes from a self-managed GitLab instance
The GitLab CI/CD integration works with self-managed GitLab: a `#junie` comment on an issue starts a pipeline that opens a merge request, and new merge requests get automated reviews.
Junie vs. competitors
Junie vs. Claude Code
Claude Code is Anthropic's coding agent for the terminal, VS Code, JetBrains IDEs, desktop, and web, tied to Claude models and Claude plans or API billing. Junie is model-agnostic across JetBrains credits, your own keys, and local models, and inside JetBrains IDEs it can drive the debugger and use the IDE's code index. Choose Claude Code to standardize on Claude, and Junie to keep model choice and IDE-level tooling.
Junie vs. OpenAI Codex
Codex is OpenAI's coding agent across a CLI, IDE extensions, cloud tasks, and ChatGPT, built around OpenAI models and ChatGPT plans. Junie supports OpenAI models alongside Anthropic, Google, xAI, and local ones, with deeper JetBrains IDE integration. Codex suits ChatGPT-centric teams, and Junie suits JetBrains users who want provider flexibility.
Junie vs. GitHub Copilot
GitHub Copilot spans many editors, including JetBrains IDEs, and its cloud agent works on GitHub issues and opens pull requests, with usage metered in GitHub AI Credits. Junie also runs from GitHub issues and pull requests through a GitHub Action on your own runners, supports GitLab, including self-managed instances, and uses the JetBrains IDE's debugger and project model. Copilot fits GitHub-centric teams across editors, and Junie fits JetBrains-centric teams.
Junie vs. Cline
Cline is a free, open-source, bring-your-own-model agent for VS Code, JetBrains, a desktop app, and the CLI. Junie is proprietary but adds JetBrains-specific debugger and database integration, JetBrains AI credits, Junie Local, and a JetBrains-maintained GitHub Action and GitLab CI/CD integration. Choose Cline for open source, and Junie for IDE-native tooling backed by JetBrains.
Frequently asked questions
What is Junie?
Junie is JetBrains' AI coding agent. Given a task in natural language, it plans the work, edits files, runs commands and tests, debugs, and reviews code. It runs as Junie CLI in the terminal, inside JetBrains IDEs and Android Studio, and from GitHub Actions or GitLab CI/CD.
How much does Junie cost?
You can start free with no card. Junie's pricing section says the free start includes 5 AI credits, while JetBrains' licensing docs list the ongoing AI Free tier at 3 AI credits per 30 days. With your own API keys you pay the provider's rates with no JetBrains markup. Otherwise, Junie's cloud usage is covered by JetBrains AI plans: for individuals, AI Pro is $10 per month with 10 AI credits per 30 days and AI Ultimate is $30 per month with 35 credits ($8.33 and $25 per month billed annually). For organizations, AI Pro is $20 per user per month with 20 credits and AI Ultimate is $60 with 70 credits. Each credit is worth $1.
Can Junie run with local models?
Yes. Junie can connect to local runtimes such as Ollama, LM Studio, or LiteLLM, and Junie Local installs a JetBrains-tuned Qwen model with the `/local` command so the agent runs without cloud calls or credits. Junie Local currently needs macOS 26 or later on an Apple Silicon M5 or newer Mac with at least 64 GB of RAM; NVIDIA RTX support on Windows is experimental.
Do I need a JetBrains IDE to use Junie?
No. Junie CLI runs on its own on macOS, Linux, and Windows, and the GitHub and GitLab integrations run in CI. The IDE adds the features that make Junie different, such as driving the debugger, using the IDE's code index and test runners, and querying configured databases.
How does Junie relate to JetBrains Air?
JetBrains Air, announced on September 22, 2026, is JetBrains' system of products for agentic development: Air in JetBrains IDEs, Air Teams, and Air Governance (formerly JetBrains Central). Junie is JetBrains' own coding agent within that system and will be supported on every Air surface, but Air is also open to other agents through the Agent Client Protocol.
Is Junie open source?
No. JetBrains publishes installers, release channels, and workflow templates on GitHub under an all-rights-reserved license, but the Junie agent itself is proprietary and its use is subject to the JetBrains AI Service terms. Running it with local models keeps prompts and code on your machine.
Junie vs Claude Code: what is the difference?
Claude Code is Anthropic's agent and uses Claude models through a Claude plan or the Anthropic API and cloud providers. Junie works with models from several providers, including Claude, through JetBrains credits, your own keys, or local models, and inside JetBrains IDEs it can drive the IDE's debugger and use its code index. Both offer a CLI, IDE integrations, and CI workflows.
Integrations & fit
Alternatives to consider
Anthropic
Developers and teams who want deep codebase reasoning, multi-file changes, and persistent project instructions in a terminal-friendly or IDE-native workflow
Paid
OpenAI
Developers and teams already paying for ChatGPT Plus, Pro, Business, or Enterprise who want one coding agent across the terminal, IDE, and parallel cloud tasks
FreemiumGitHub (Microsoft)
Developers on GitHub who want AI completion, chat, and agents embedded in their existing IDE and GitHub workflow
Freemium
Cline
Developers and teams who want an open-source, model-agnostic AI coding agent they fully control, in their existing IDE or terminal
FreemiumAbout Junie
Junie is one agent engine behind several surfaces. Junie CLI runs in the terminal on macOS, Linux, and Windows, the same agent appears in the AI Chat and a dedicated tool window in JetBrains IDEs and Android Studio (connected over the Agent Client Protocol), and a GitHub Action and a GitLab CI/CD integration let you hand it work by mentioning it in an issue, pull request, or merge request. What sets it apart from editor-agnostic agents is the IDE connection: inside a JetBrains IDE, Junie uses the IDE's semantic index, build configurations, test runners, and debugger, so it can set breakpoints (even in library code or decompiled classes), inspect real runtime state, and query databases configured in the IDE instead of guessing from log statements. Advanced Plan mode writes a structured plan with requirements, design, and delivery stages to `.junie/plans`, where you can edit and commit it before any code changes, and you can plan on a strong model and implement on a cheaper one. Other tools include live prompting to steer a running task, an action allowlist with per-command approval, `/review` for local or CI code review, `/demo` to launch your app in a Docker environment and record a video of a feature working, guidelines and Agent Skills, MCP servers, and remote control to monitor long tasks from another device. Junie is model-agnostic: it can use models through a JetBrains AI subscription, your own keys for OpenAI, Anthropic, Google, xAI, OpenRouter, GitHub Copilot, or LiteLLM, or a local runtime such as Ollama or LM Studio. Junie Local, launched on August 24, 2026, installs a Qwen-based model that JetBrains chose and tuned for its agent loop and runs it entirely on the machine, but it currently needs macOS 26 on an Apple Silicon M5 Mac with 64 GB of RAM or more, with experimental NVIDIA RTX support on Windows in nightly builds. Junie is also the JetBrains coding agent inside JetBrains Air, the system of products for agentic development that JetBrains announced on September 22, 2026. Junie left beta on June 17, 2026. The tradeoffs: its strongest features (debugger and database integration) depend on a JetBrains IDE and AI subscription, cloud usage is metered in AI credits, which JetBrains says agent mode and expensive models consume faster, and Junie itself is not open source.
Updates from Junie
Junie CLI release 26.9.22 builds on September 29, 2026 added Claude Sonnet 5.5 and GPT-6.1 Sol support and fixed false safety refusals with Claude Opus 5. The September 22 build had added Claude Opus 5.5, GPT-6 Sol and Luna, and Grok 4.7.
JetBrains announced JetBrains Air, a system of products for agentic development that includes Air in JetBrains IDEs, Air Teams, and Air Governance (formerly JetBrains Central). JetBrains says Junie will be supported across all Air surfaces, while Air also stays open to other agents through ACP.
Junie Local added Qwen3.8-3.6-27B-blend, which JetBrains says completed more tasks than Qwen3.6 in its internal benchmark while producing far fewer output tokens than Qwen3.8, and nightly builds gained experimental support on Windows for NVIDIA RTX cards based on Ampere or newer with at least 24 GB of VRAM.
The `/demo` command builds and launches your app in a Docker environment, exercises the requested flow, and returns a video, screenshots, and an HTML report with passed, failed, and incomplete checks.
Junie became generally available with Advanced Plan mode, agentic debugging in JetBrains IDEs, remote control, context-aware code review, and an IDE integration rebuilt on ACP.
Are you the founder? Claim this listing →