JetBrains AI: Junie, the Agent Client Protocol, and the Case for an Open IDE Ecosystem
While the Gartner Leaders compete on model quality and agent speed, JetBrains is playing a different game: building an open protocol (ACP) that lets any agent run inside any JetBrains IDE, paired with its own Junie autonomous agent and deep IDE-native context. This article examines JetBrains' 2026 AI strategy, the Junie agent capabilities, the Agent Client Protocol standard, and why the IDE-as-control-plane thesis may matter more than the model war.
JetBrains AI: Junie, the Agent Client Protocol, and the Case for an Open IDE Ecosystem
Executive Summary
In the spring of 2026, while the Gartner Magic Quadrant Leaders (GitHub, Anthropic, OpenAI, Cursor) compete on model quality, benchmark scores, and agent speed, JetBrains is executing a quietly radical strategy: making the IDE an open control plane for any AI agent, not a walled garden for one.
This strategy rests on three pillars:
- Junie — JetBrains' own autonomous coding agent, achieving 51.8% on SWE-bench, deeply integrated into 20+ JetBrains IDEs with access to semantic code intelligence, type hierarchies, and project structure.
- Agent Client Protocol (ACP) — An open standard (Apache 2.0, protocol version 1.0) that allows any coding agent to connect to any JetBrains IDE. Cursor, Claude Agent, and OpenAI Codex all run natively inside IntelliJ, PyCharm, WebStorm, and GoLand through ACP.
- Zero vendor lock-in — Four activation pathways (JetBrains subscription, Bring Your Own Key, OAuth, ACP agents) ensure developers are never tied to a single model provider.
Key Finding: JetBrains is not trying to win the model war. It's trying to make the model war irrelevant by building the infrastructure layer that sits above it. The thesis is simple: the best model today won't be the best tomorrow, so the IDE should be the stable platform that works with whatever agent is best for the task at hand.
This represents a fundamental philosophical split in the AI coding market: vertical integration (own the model, own the agent, own the IDE — Cursor, GitHub) vs. horizontal platform (own the IDE, let the best agent win — JetBrains).
I. The 2026 Strategy: "Two Valid Ways of Writing Code"
The Official Position
JetBrains articulated its 2026 AI direction in a April 2026 blog post with a deceptively simple thesis:
"There are two ways developers create code now: the classic way (typing, refactoring, debugging, building up intent line by line) and the new way (collaborating with AI — sometimes via autocomplete, sometimes via an agent that drafts whole chunks of work). We don't think one is better than the other."
This is not neutral phrasing. It's a direct challenge to the narratives driving Cursor, Claude Code, and Codex — all of which are optimizing for AI-first workflows that increasingly displace the traditional coding experience.
Five Product Commitments
JetBrains codified its strategy into five commitments:
| # | Commitment | What It Means |
|---|---|---|
| 1 | AI and classic modes coexist | No nudging users into a single "approved" workflow |
| 2 | Agents respect the IDE promise | Deep code intelligence, safe refactoring, debugging, inspections remain intact |
| 3 | Zero vendor lock-in | Multiple activation pathways; workflow never tied to single vendor |
| 4 | Long-term utility over hype | Real retention on real projects, not demo-day features |
| 5 | Candid community feedback | Prioritizing honest Reddit/Marketplace reviews over polished marketing |
The Anti-Confusion Stance
JetBrains is explicit about what it's pushing back against:
"We're not anti-AI. We're anti-confusion."
The concern is specific: agents that generate code without visibility, without reversibility, without understanding of impact on the broader codebase. JetBrains' baseline expectation is "boring" by design:
- Changes must be visible
- Changes must be reversible
- The project must not be left in a broken state ("no red code")
- Generated code must be readable, reviewable, changeable, and revertible
This is a direct response to the "Ralph-loop" phenomenon — agents that generate code in tight loops without human oversight, creating technical debt that's invisible until production.
II. Junie: The Native Autonomous Agent
What Is Junie?
Junie is JetBrains' answer to Cursor Composer, Claude Code, and OpenAI Codex. Launched in January 2026, it's an autonomous coding agent that lives inside the IDE (and also as a standalone CLI tool), capable of:
- Autonomous exploration — Navigating project structure to find relevant files
- Multi-file code generation — Writing and modifying code across entire modules
- Test execution — Running tests to verify changes before presenting results
- Terminal operations — Executing shell commands, Git operations, file management
- Human-in-the-loop — Only asking for confirmation when encountering ambiguity
SWE-bench Performance
| Agent | SWE-bench Score | Key Strength |
|---|---|---|
| Claude Code (Opus 4.7) | ~55-60% | Code quality, complex reasoning |
| OpenAI Codex (GPT-5.5) | ~49% | Terminal autonomy, speed |
| Cursor Composer 2.0 | ~52% | Codebase context, DX |
| Junie | 51.8% | IDE-native semantic understanding |
Junie's 51.8% is competitive but not leading. What differentiates it is not raw benchmark performance but the quality of its integration. Where Claude Code and Codex must infer project structure from file reads and grep, Junie has direct access to:
- IntelliJ's semantic analysis engine (type hierarchies, dependency graphs)
- IDE inspections and code quality checks
- Build system integration (Gradle, Maven, Bazel)
- Test runner integration (JUnit, pytest, Jest)
- VCS integration (Git, Mercurial, Perforce)
Cost Efficiency
According to JetBrains' MENA launch announcement (May 2026), Junie delivers the same high-quality output as top-tier models at up to 4x lower cost based on SWE-rebench results. The efficiency comes from grounding work in actual codebase reality rather than prompt-based guesses, reducing wasted token spend on incorrect assumptions.
Junie CLI: Beyond the IDE
Junie is not limited to the IDE. The standalone CLI tool (junie) supports:
- Terminal-based autonomous coding
- CI/CD pipeline integration (GitHub Actions)
- Natural language task delegation ("Fix the failing tests in the auth module")
- Multiple authentication methods (JetBrains Account, API Key, BYOK)
# Installation
curl -fsSL https://junie.jetbrains.com/install.sh | bash
# Usage
junie "Build a web dashboard that shows open issues, recent commits, and CI status"
junie "Review the current changes in this branch and highlight potential bugs"
junie "Fix the failing tests in the auth module and add a regression test"
III. The Agent Client Protocol (ACP): The Open Standard
What Is ACP?
The Agent Client Protocol is an open standard (Apache 2.0 license) that standardizes communication between code editors and coding agents. Protocol version 1.0 is stable, with SDKs available in:
- Kotlin (JVM, multiplatform)
- Java
- Python
- Rust
- TypeScript
The protocol is designed so that agents can be installed from a curated registry or configured manually, appearing inside the IDE's AI Chat tool window alongside native agents.
Why ACP Matters
ACP represents a fundamental architectural shift. Before ACP, every agent needed a bespoke integration for every IDE. The integration matrix was n² (n agents × n editors). With ACP, it becomes n + m (n agents + m editors), because any ACP-compliant agent works with any ACP-compliant client.
Current ACP Registry Agents:
| Agent | Provider | Integration Status |
|---|---|---|
| Junie | JetBrains | Native (first-party) |
| Claude Agent | Anthropic | ACP SDK available |
| Codex | OpenAI | Native integration (pre-ACP) |
| Cursor | Anysphere | ACP Registry (May 2026) |
| Custom agents | Community | Manual configuration |
The Cursor Integration: A Signal
The most significant ACP adoption signal is Cursor's integration. Cursor was one of the most-requested additions to the ACP registry. As of May 2026, developers can select Cursor from the agent picker inside IntelliJ IDEA, PyCharm, WebStorm, and GoLand — using Cursor's agentic workflow without leaving their JetBrains IDE.
This is a powerful statement: JetBrains is willing to make its IDE the host for its biggest competitor's agent. This is the opposite of the walled-garden strategy pursued by Cursor (which requires switching editors) and GitHub (which optimizes for its own ecosystem).
Qt Creator 20 (beta, May 2026) also adopted ACP, bringing agent support to the C++ ecosystem. Zed has also launched an official ACP Registry integration, confirming that ACP is gaining traction beyond the JetBrains ecosystem.
ACP vs. MCP: Two Protocols, Two Layers
ACP does not compete with the Model Context Protocol (MCP). They operate at different layers:
| Dimension | ACP (Agent Client Protocol) | MCP (Model Context Protocol) |
|---|---|---|
| Purpose | Connects editors to agents | Connects agents to tools/data sources |
| Analogy | Like LSP (Language Server Protocol) for agents | Like a universal tool adapter |
| Scope | Editor ↔ Agent communication | Agent ↔ Database/API/Filesystem |
| Session | Stateful (multi-turn agent sessions) | Stateless (per-call tool invocations) |
| Streaming | Delta-style streaming for live diffs | No delta streaming |
| Multi-agent | Supports agent orchestration | Single-agent focused |
| Adoption | JetBrains IDEs, Qt Creator 20, Zed | VS Code, Claude, Sourcegraph, Replit |
The relationship: An ACP-connected agent (like Junie or Codex inside IntelliJ) can use MCP to access external tools (databases, APIs, documentation servers). ACP handles the editor-agent relationship; MCP handles the agent-tool relationship. They are complementary, not competing.
As one analysis puts it: "ACP does for code editors what MCP does for data sources."
ReSharper 2026.2: ACP in Visual Studio
The ReSharper 2026.2 EAP (launched May 11, 2026) extends ACP support to Visual Studio. This is significant because:
- It brings Junie to .NET developers inside Visual Studio (not just Rider)
- It validates ACP as a cross-IDE protocol, not just a JetBrains-internal standard
- It opens the path for the ACP Agent Registry inside Visual Studio
"We believe developers shouldn't be locked into a single ecosystem to get their work done." — JetBrains, ReSharper 2026.2 EAP announcement
IV. The Multi-Model Architecture
Model Agnosticism as Strategy
JetBrains AI Assistant supports multiple models with per-conversation switching:
| Model | Best For | Availability |
|---|---|---|
| GPT-5 | Complex reasoning | Ultimate tier |
| Claude 4.5 Sonnet | Code quality | Ultimate tier |
| Gemini 2.5 Pro | Large context windows | Ultimate tier |
| GPT-4.1 | Balanced performance | Pro/Ultimate |
| Claude 3.7 Sonnet | Cost-effective | Pro/Ultimate |
| Local models (Ollama, LM Studio) | Privacy, offline | All tiers |
The system displays cost/performance metrics for each model, helping users find the optimal balance between speed, accuracy, and credit consumption.
Local Model Support
All tiers support fully local models via Ollama, LM Studio, llama.cpp, and LiteLLM. Local models consume no credits, and models like DeepSeek Coder V2 running locally approach cloud-model quality for many tasks. This is particularly relevant for:
- Strict data governance policies (finance, healthcare, government)
- Air-gapped environments
- Offline development
- Cost optimization for routine tasks
Credit System
JetBrains uses a unified credit system rather than per-token billing:
- AI Free: 3 credits/month + unlimited local completions
- AI Pro: Shared credit pool (Junie + Claude Agent + cloud completions)
- AI Ultimate: $35/month in AI Credits + $5 bonus + 12-month rollover
The credit system abstracts away the complexity of per-token pricing across multiple providers, while the rollover mechanism prevents waste.
V. Pricing: The Value Proposition
Tier Comparison
| Feature | AI Free | AI Pro ($8/mo) | AI Ultimate ($30/mo) |
|---|---|---|---|
| Local completions | Unlimited | Unlimited | Unlimited |
| Cloud completions | Limited | Enhanced | Unlimited |
| Junie Agent | No | Shared credits | Full access |
| Claude Agent | No | Shared credits | Full access |
| GPT-5, Claude 4.5 | No | No | Yes |
| Monthly credits | None | Shared pool | $35 included |
| All Products Pack | N/A | Included free | Add $22/mo |
| Best for | Evaluators | Most developers | Power users |
Competitive Pricing Analysis
| Tool | Price | Agent Capability | Model Choice | IDE Support |
|---|---|---|---|---|
| JetBrains AI Pro | $8/mo | Junie (shared) | Multiple | JetBrains only |
| GitHub Copilot | $10/mo | Agent (preview) | GPT-4 Turbo | VS Code, JetBrains, VS |
| Cursor | $20/mo | Composer 2.0 | Proprietary | Cursor only |
| Claude Code | $20-200/mo | Full agent | Claude family | CLI, VS Code, JetBrains |
| Windsurf | $15/mo | Agent | Multiple | 40+ editors |
Key insight: At $8/month, JetBrains AI Pro undercuts every competitor while offering comparable agent capabilities. For existing All Products Pack subscribers ($249/yr), AI Pro is included free — making it effectively the cheapest full-featured AI coding assistant on the market.
VI. The Gartner Position: Niche Player with Strategic Depth
Where JetBrains Sits
In Gartner's 2026 Magic Quadrant for Enterprise AI Coding Agents, JetBrains was placed in the Niche Players quadrant. This reflects:
- Moderate Ability to Execute: Strong within the JetBrains ecosystem, but limited market reach compared to the Leaders
- Moderate Completeness of Vision: The ACP strategy is compelling but still early in adoption
The Niche Player Advantage
The Niche Player designation should not be read as weakness. JetBrains' niche is deliberately chosen:
- Deep IDE integration — No other agent understands JVM code (Java, Kotlin, Groovy, Spring Boot) at the semantic level JetBrains does
- Open protocol strategy — While Leaders compete on closed ecosystems, JetBrains is building the infrastructure for an open market
- Developer trust — 22M+ plugin downloads, 77% of developers reporting productivity improvements (JetBrains Developer Ecosystem Survey 2024)
The risk for JetBrains is that if ACP adoption accelerates and other IDEs implement it (VS Code, Neovim, Zed), the IDE integration moat could erode. But the counter-argument is that deeper integration creates higher switching costs — developers who build their workflow around JetBrains' semantic intelligence won't leave easily.
VII. Agent Skills: Reusable Expertise
The Problem Agents Solve Poorly
One of the weakest points of current AI coding agents is inconsistency. Ask an agent to write tests, and you get different results each time. Ask it to debug a flaky test, and it may loop endlessly without finding the root cause.
JetBrains' Solution: Agent Skills
JetBrains introduced Agent Skills — reusable, installable expertise packages that turn one-off prompts into deterministic workflows. Skills:
- Combine with developer tools (test runners, linters, coverage tools)
- Make AI debugging more deterministic
- Can be installed once and used across agents and projects
- Are verified by JetBrains for quality and safety
Example: The finding-tests Skill
Launched in May 2026 for Rider (and available as a standalone MCP tool), the finding-tests skill surfaces .NET coverage data to Claude Code and Codex, enabling agents to:
- Target untested branches specifically
- Reduce AI cost for test generation by avoiding redundant test writing
- Generate tests with higher coverage effectiveness
This is a subtle but important evolution: instead of giving agents more tokens, give them better context.
VII.1 Koog 1.0: The JVM Agent Framework
What Is Koog?
Announced at KotlinConf 2026 (May 2026), Koog 1.0 is JetBrains' open-source framework for building AI agents in Kotlin and Java. It provides the core building blocks for agentic applications:
- Tools — Structured tool definitions for agent capabilities
- Workflows — Composable, deterministic agent workflows
- Persistence — Long-running agent state management
- Memory — Context-aware memory systems
- Observability — OpenTelemetry integration across all targets
- Multiplatform — Backend services, Android, iOS, JVM, and in-browser
The 1-Year API Stability Guarantee
The biggest change in Koog 1.0 is a strict commitment to stability:
"We guarantee no breaking changes for stable modules for at least one year."
This is a direct response to the chaos of the AI agent framework landscape, where breaking changes every release make production deployment risky. By offering a 1-year stability guarantee, JetBrains is signaling that Koog is ready for enterprise backends, not just prototyping.
Key Improvements in 1.0
| Feature | Impact |
|---|---|
| Local Android AI | LiteRT model support for on-device inference |
| Redesigned Java interop | Cleaner, more consistent API for Java projects |
| Decoupled HTTP transport | Easier integration with existing infrastructure |
| OpenTelemetry | Full observability across Kotlin Multiplatform |
| Improved persistence | Better support for long-running agent sessions |
| Anthropic prompt caching | Reduced latency and token costs for repeated prompts |
Why Koog Matters for the Strategy
Koog completes the JetBrains AI stack:
- IDE layer — AI Assistant with Junie, ACP, multi-model support
- Protocol layer — ACP for editor-agent communication
- Framework layer — Koog for building production agents on the JVM
This positions JetBrains not just as an IDE vendor but as a full-stack AI infrastructure provider for the JVM ecosystem. The 1-year stability guarantee is particularly significant — it's the kind of commitment that enterprises need before deploying AI agents in production.
VII.2 The JetBrains x Codex Hackathon: What Happens When Agents Live in the IDE
The Event
In May 2026, JetBrains and OpenAI hosted the inaugural JetBrains x Codex Hackathon in San Francisco. The results speak to the maturity of the IDE-as-control-plane thesis:
- 443 developers applied
- 39 projects shipped in a single weekend
- 6 finalists presented compelling use cases
The Six Finalists
| Place | Project | Team | What It Does |
|---|---|---|---|
| 🥇 1st | hyperreasoning | Aditya Mangalampalli | Replaces single-shot LLM calls with a search-based approach: drafts multiple approaches, a learned controller decides which to expand/cut/verify, compiler errors feed back into the controller |
| 🥈 2nd | Scopecreep | Sheoran, Ross, Javadyan, Im | Collapses hardware bring-up (schematic viewer, oscilloscope, power supply, terminal) into a single IDE tool window with human-in-the-loop probe placement |
| 🥉 3rd | mesh-code | Ojha, Cao, Ise, DRAM | Gives agents shared memory across machines — a session that begins on one laptop continues on another with whichever agent is available |
| — | Periscope | Wes McKinney (agentsview) | Shows what's filling an agent's working memory turn-by-turn, recommends compacting/rewinding/forking/handing off |
| — | SecureLoop | Sribhashyam, Marri, Li | Automated security incident response: agent gathers code + security rules + dependencies, Codex proposes fix, runs automated checks, opens PR (human approves merge) |
| — | Pinpoint | Het Patel | Developers drop pins on live pages with comments, agent gets precise on-page context instead of vague "move that element" instructions |
What the Finalists Show
Looking across these six projects, a clear pattern emerges:
- The IDE as a reasoning layer — Not just a place to write code, but a place to watch an agent think, direct its reasoning, and manage its attention
- Human-in-the-loop by design — Every finalist project preserves human agency at the critical decision points
- Cross-domain applicability — Agents in the IDE aren't just for coding; they're for hardware bring-up, security incident response, frontend design, and more
- Visibility over automation — The most compelling projects make the agent's reasoning visible and directable, rather than hiding it behind a black box
As JetBrains summarized: "Codex embedded in the IDE isn't just a faster way to write code — it's a reasoning layer you can watch think, a structured output engine you can direct, a participant in workflows that span hardware instruments, production alerts, shared session state, and context windows."
VII.3 IDE-Native Search Tools: Faster and Cheaper Agents
The Experiment
JetBrains ran a controlled experiment comparing agents with and without IDE-native search tools. The hypothesis: when agents use the IDE's own search (symbol lookup, regex, file search) instead of shell tools (grep, find), they become faster and cheaper.
Methodology
- Paired delta analysis — Identical coding tasks run with and without prebundled tooling
- Four metrics tracked — Quality (tests passed), latency (median/P95), cost (dollars), budget discipline (tasks exceeding $0.50 cap)
- Statistical rigor — Improvements reported only when p < 0.05 with 95% confidence intervals
- Cross-model validation — Tested across GPT-5.4, Claude, and Haiku on Java and Kotlin codebases
Results
| Metric | Improvement | Significance |
|---|---|---|
| Latency | Reduced (statistically significant) | p < 0.05 |
| Cost | Reduced (statistically significant) | p < 0.05 |
| Quality | No statistically significant change | N/A |
| Kotlin cost | 13.48% reduction | Largest improvement |
Model Adoption Patterns
The experiment revealed an interesting pattern in how different models adopt tooling:
| Model | IDE-Native Tool Adoption | Behavior |
|---|---|---|
| Codex | 91% of search calls | Grabs the better tool immediately |
| Claude Opus | ~50% of search calls | Uses it for about half its searches |
| Claude Haiku | 28% of search calls | Prefers grep and find |
Key insight: Prebundled tooling fills gaps. Where the model already has good search (Claude), it adds less. Where search is weak (Codex), it makes a real difference.
Implications
This experiment validates the core JetBrains thesis: the IDE's semantic intelligence is a force multiplier for agents. The IDE isn't just a host — it actively makes agents better by providing tools that are deeper, more precise, and more efficient than generic shell commands.
The winning configuration (prebundled search skill + unified IDE-native tool + universal router) is being prepared for the integrated IntelliJ IDEA MCP Server and will be enabled by default in upcoming AI Assistant plugin updates.
VIII. Architecture Comparison: Vertical vs. Horizontal
The Two Models
Implications
| Dimension | Vertical (Cursor, GitHub, Anthropic) | Horizontal (JetBrains) |
|---|---|---|
| Optimization | End-to-end tuned for one model | Optimized for IDE experience across models |
| Switching cost | High (locked to editor + model) | Low (swap agents without leaving IDE) |
| Innovation speed | Fast (control full stack) | Depends on ecosystem adoption |
| Risk | Model obsolescence | Protocol adoption risk |
| Enterprise fit | Good for standardization | Good for flexibility |
IX. Real-World Use Cases
Who Should Choose JetBrains AI?
| Use Case | Fit | Why |
|---|---|---|
| Java/Kotlin/Spring Boot development | ⭐⭐⭐⭐⭐ | Unmatched semantic understanding of JVM ecosystem |
| JetBrains IDE power user | ⭐⭐⭐⭐⭐ | Native integration, no context switching |
| Budget-conscious developer | ⭐⭐⭐⭐⭐ | $8/mo Pro is best value in market |
| Need for autonomous refactoring | ⭐⭐⭐⭐ | Junie handles complex multi-file tasks |
| Multi-agent workflow | ⭐⭐⭐⭐ | ACP enables switching between agents per task |
| VS Code primary user | ⭐ | Not optimized for VS Code workflow |
| Need for simplest pricing | ⭐⭐ | Credit system adds complexity vs. flat-rate Copilot |
Who Should Look Elsewhere?
- VS Code-native teams: Cursor or GitHub Copilot provide better VS Code integration
- Teams wanting simplest pricing: GitHub Copilot's flat $10/mo is easier to budget than credit-based systems
- Teams already locked into Anthropic/OpenAI: Claude Code or Codex may provide better end-to-end experience within their ecosystems
X. The Bigger Picture: What JetBrains Is Betting On
The Thesis
JetBrains is betting that the IDE will remain the control plane for professional software development, even as AI agents generate more and more code. The reasoning:
- Someone must own the code. Agents can generate it, but humans must review, understand, and take responsibility for what ships.
- The IDE is the best place to do that. No other tool provides the same depth of code intelligence, refactoring safety, and project context.
- The best model changes constantly. Building an IDE that works with whatever agent is best today is more sustainable than betting on one model.
The Risk
The risk is that agents become good enough that the IDE becomes a passive viewer rather than an active tool. If an agent can generate, test, review, and deploy code without human intervention, the IDE's role shrinks to "approval button."
JetBrains' mitigation is the Agent Skills system and the emphasis on visibility and reversibility. The goal is to keep the IDE as the place where code is understood, not just generated.
The Market Signal
The ACP protocol itself is the biggest market signal. By open-sourcing the protocol and enabling competitors' agents (Cursor) to run inside its IDE, JetBrains is attempting to become the TCP/IP of AI coding — the foundational protocol that everyone builds on, rather than another vertical player in the stack.
If successful, this positions JetBrains not as a competitor to Claude Code or Codex, but as the platform they run on.
XI. Key Takeaways
-
JetBrains is playing a different game. While Leaders compete on model quality and benchmark scores, JetBrains is building the infrastructure layer (ACP) that sits above the model war.
-
Junie is competitive but not leading. At 51.8% SWE-bench, it's in the same league as Cursor Composer and Codex. Its differentiator is IDE-native semantic understanding, not raw agent capability.
-
ACP is the strategic bet. By open-sourcing the agent-IDE protocol and enabling competitor agents, JetBrains is attempting to become the platform layer for AI coding.
-
Pricing is aggressive. At $8/month for AI Pro (free with All Products Pack), JetBrains offers the best value in the market for JetBrains IDE users.
-
The IDE-as-control-plane thesis is unproven. JetBrains is betting that professional developers will always need the IDE as their primary interface, even as agents generate more code. Time will tell.
-
Not for everyone. If you're a VS Code user or want the simplest pricing, other tools may be better fits. JetBrains AI is optimized for JetBrains IDE power users, especially in the JVM ecosystem.
XII. References & Resources
- JetBrains AI Blog: Our 2026 Direction
- JetBrains AI Assistant Documentation
- Agent Client Protocol (GitHub)
- ACP Registry
- Junie GitHub Repository
- Junie Official Website
- ReSharper 2026.2 EAP Announcement
- JetBrains x Codex Hackathon
- Koog 1.0 Announcement
- IDE-Native Search Tools Experiment
- Gartner Magic Quadrant: Enterprise AI Coding Agents 2026 (referenced via Gartner Magic Quadrant Enterprise Ai Coding Agents 2026 05 26)
- [Enterprise AI Coding Agents Showdown](Enterprise Ai Coding Agents Showdown Claude Codex Cursor Github 2026 05 27)
- [Tabnine: The Enterprise Context Engine](Tabnine Enterprise Context Engine Gartner Visionary 2026 05 27)
XIII. Future Directions
What to Watch
- ACP adoption beyond JetBrains. Will VS Code, Neovim, or Zed implement ACP? If so, JetBrains' platform strategy gains massive validation.
- Junie's benchmark trajectory. Can Junie close the gap with Claude Code and Codex on SWE-bench? The IDE-native context advantage should compound over time.
- Agent Skills ecosystem. Will third-party Skills become a vibrant market? This could be the app store moment for AI coding agents.
- ReSharper ACP maturity. Full ACP support in Visual Studio could bring JetBrains' open ecosystem strategy to the .NET world.
- Pricing evolution. Will the credit system simplify, or will competitors adopt similar models?
The Question No One Is Asking
The biggest question about JetBrains' strategy isn't whether ACP will succeed — it's whether the market wants an open protocol at all. The Leaders have strong incentives to keep their ecosystems closed (lock-in drives revenue). If JetBrains becomes the platform layer, it needs the Leaders to participate voluntarily.
The Cursor integration is a promising first signal. But the real test will be whether Anthropic and OpenAI choose to build ACP-native agents, or whether they continue optimizing for their own ecosystems.
The answer to that question will determine whether JetBrains becomes the TCP/IP of AI coding — or remains a very good niche player in a fragmented market.