JetBrains Junie Goes Async: GitHub Integration and 30% Speed Boost

TL;DR

• Junie now integrates with GitHub for async development — delegate tasks without opening your IDE
• In-IDE agent is 30% faster and adds MCP support for connecting external data sources
• 83% of managers report increased team productivity, 76% satisfaction rate
• GitHub integration in EAP for JVM and PHP; open-source projects can apply for free 6-month licenses

The Big Picture

JetBrains is betting that developers don't want the fastest AI agent — they want the smartest one. While tools like Cursor and GitHub Copilot race to shave milliseconds off response times, Junie takes a different approach: transparent reasoning, structured task planning, and now, the ability to work completely asynchronously through GitHub.

The async angle is the real story here. Most AI coding agents live inside your IDE, which means you're stuck waiting for them to finish before moving on. Junie's new GitHub integration breaks that model. You can delegate a bug fix in one repo, spin up a feature in another project, and review both later — all without opening an IDE. For developers juggling multiple codebases or working in teams, this changes the workflow fundamentally.

JetBrains surveyed 272 developers and managers in June 2025. The numbers are solid: 83% of managers say Junie increases team productivity, and 76% report satisfaction or high satisfaction. Those aren't revolutionary figures, but they're strong enough to suggest Junie has found product-market fit with teams that value control and transparency over raw speed.

How It Works

Junie's GitHub integration lets you treat the agent like a remote team member. You assign tasks through GitHub issues or comments, and Junie executes them in the background. No IDE required. The agent creates branches, writes code, and opens pull requests. You review when you're ready.

The workflow looks like this: tag Junie in a GitHub issue with a task description. Junie analyzes the codebase, generates an execution plan, and starts working. It logs every action with reasoning — not just "changed file X" but "changed file X because Y." When it's done, you get a PR with a full breakdown of what changed and why. You can approve, request changes, or hand it off to a teammate for review.

This is fundamentally different from in-IDE agents. With Cursor or JetBrains' own AI Assistant, you're in a synchronous loop: you ask, it responds, you iterate. Junie on GitHub is asynchronous: you delegate, it works independently, you review in batch. The mental model shifts from "assistant" to "junior developer who works overnight."

The in-IDE version of Junie also got major upgrades. It's now 30% faster at task completion, though JetBrains doesn't specify whether that's latency, throughput, or end-to-end time. More interesting is MCP support. The Model Context Protocol — originally developed by Anthropic — lets Junie connect to external data sources like databases, APIs, or file systems. That means the agent can query your production database schema, pull data from internal APIs, or read config files outside the project directory.

Remote development support is now live for macOS and Linux. You can work on a remote server or VM and delegate tasks to Junie simultaneously. This matters for teams running dev environments in the cloud or working with large codebases that don't fit on local machines.

One notable limitation: GitHub integration is currently JVM and PHP only. No Python, JavaScript, or Go yet. JetBrains is running this as an Early Access Program, so broader language support is likely coming, but if you're not in the JVM or PHP ecosystem, you're waiting.

What This Changes For Developers

The async model solves a real problem: context switching. If you're deep in a complex feature and a bug report comes in, you have two bad options. Drop what you're doing and fix it, or let it sit until you're done. Junie on GitHub gives you a third option: delegate the bug fix and keep working. Review the fix later when you're between tasks.

This is especially useful for small teams. If you're a solo developer maintaining multiple projects, you can queue up tasks across repos and batch-review them at the end of the day. If you're on a team, you can assign Junie a task, have a teammate review the PR, and merge it without ever touching the code yourself. That's a new workflow pattern that doesn't exist with traditional in-IDE agents.

The transparency angle matters too. Junie logs every action with reasoning. That's critical for trust. If an agent changes a config file or refactors a function, you need to know why. Spec-driven development is becoming the norm for AI agents, and Junie's detailed execution plans fit that model well.

MCP support opens up new use cases. You can connect Junie to your internal API docs, let it query your database schema, or pull in data from third-party services. That's a step toward agents that understand your entire stack, not just the code in front of them. It's early days for MCP adoption, but JetBrains is betting it becomes a standard protocol for agent-to-tool communication.

The 30% speed boost is nice but not transformative. Junie was never the fastest agent, and it still isn't. The value prop is quality and control, not speed. If you're optimizing for raw throughput, Cursor or Copilot are still faster. If you want an agent that explains its reasoning and doesn't surprise you with unexpected changes, Junie is the better pick.

Try It Yourself

The GitHub integration is in Early Access. You can sign up through the JetBrains website. If you're working on an open-source project, JetBrains is offering free 6-month licenses. You apply through a form, describe your project, explain how you'll use Junie, and they review applications on a rolling basis.

For in-IDE usage, Junie is available as a plugin for IntelliJ IDEA, PyCharm, WebStorm, and other JetBrains IDEs. Pricing is subscription-based, though JetBrains hasn't published updated pricing for the GitHub integration yet.

If you're already using JetBrains IDEs and want to experiment with async agent workflows, this is worth testing. The EAP is the right time to give feedback before the feature locks in.

The Bottom Line

Use Junie if you value transparency and control over speed, or if you're juggling multiple projects and need async task delegation. The GitHub integration is genuinely new — no other major AI coding agent offers this workflow yet. Skip it if you're not in the JVM or PHP ecosystem, or if you need the absolute fastest agent and don't care about detailed reasoning logs.

The real risk here is adoption. Async agent workflows are unfamiliar. Developers are used to synchronous back-and-forth with AI tools. JetBrains is asking you to change your mental model and trust an agent to work independently. That's a harder sell than "it's faster." But if the workflow clicks, it could be a significant productivity unlock for small teams and solo developers managing multiple codebases.

Source: Junie