How JetBrains Is Reinventing IDEs with AI Agents and the New ACP Protocol

1. AI Workflow in IDE: From Editor‑First to Agents

JetBrains initially treated AI as an editor‑first assistant, providing multi‑line code completion and "next‑hop prediction" where the cursor jumps to the next variable reference after a rename. Their Malam 14B model introduced a "hotspot pause" that lets developers intervene after each completion step, aligning AI actions with developer intent.

As model capabilities grew, AI expanded from line‑level assistance to cross‑file tasks, enabling AI chat, multi‑file editing, and codebase semantic search powered by the IDE's indexing system.

2. Early Exploration Challenges

Model capability variance and heavy prompt‑engineering reliance – Early models like GPT‑3.5 were unstable and required extensive, language‑specific prompts (e.g., generate-unit-tests|python) to produce usable code.

Prompt‑engineering complexity and management – The team built a Kotlin‑based framework called Koog (similar to LangChain) to organize prompts and agents.

IntelliJ Platform technical debt – The platform lacked dedicated extension points for AI, forcing the team to "magically" modify core interfaces and causing community backlash.

3. Breaking the Deadlock: Building a Platform‑Ready AI IDE

JetBrains shifted from a plugin model to embedding AI as a core capability. They created an evaluation suite ( LLM Eval ) to benchmark model performance on tasks such as generating five better variable names while respecting project naming conventions.

Key architectural changes include:

Codebase Q&A platformization – Leveraging the PSI (Program Structure Interface) index for local RAG, avoiding external dependencies.

MCP Server plugin – Exposes core IDE capabilities (debug data, indexing, static analysis) via the new protocol.

4. CLI Agent vs. AI IDE Positioning

CLI agents focus on generation tasks (e.g., scaffolding a project), while AI IDEs handle the full development workflow, offering deep editing interaction, atomic refactoring, runtime state awareness, and global context understanding.

Deep editing interaction: line‑level completion, next‑hop prediction, hotspot pause.

Atomic safety refactoring: IDE‑based AST refactoring versus non‑atomic CLI changes.

Runtime state awareness: IDE can analyze variables, stack, memory, and provide root‑cause analysis (RCA), which CLI agents cannot.

Global context: IDE uses project index for precise code‑base queries.

Strong workflow integration: AI features are embedded in editing, debugging, and version control.

5. Architecture Evolution: Splitting the Junie Agent

The monolithic Junie agent was split to address two problems: conservative prompt design and difficulty implementing background agents. The split introduced:

Feature delegation – Moving IDE‑dependent features (hooks, indexing, session management) back to the IntelliJ Platform.

Process management – Each coding agent runs as an independent subprocess.

Dual implementation – Some tools retain both file‑system and IDE API implementations.

During the split, the team replaced their custom rd-protocol with the Agent Client Protocol (ACP) , a lightweight JSON‑RPC protocol compatible with MCP, enabling easy integration of external agents.

6. Agent Client Protocol (ACP)

ACP provides a bridge between isolated agents and the IDE, allowing developers to choose any coding agent (JetBrains Junie, Claude Code, Gemini, etc.) without additional configuration. It standardizes capability discovery, session management, and tool invocation.

Developers can freely select agents.

IDE capabilities (diff, search, refactoring) are exposed via ACP, reducing agent configuration.

Low integration cost for CLI‑based agents.

Clear separation of concerns: IDE focuses on editing and debugging, agents focus on code generation.

7. Demo: Integrating Gemini CLI with ACP

The demo shows a Kotlin JVM program using the Kotlin ACP SDK to wrap the Gemini CLI. The client sends a request like "add a new parameter to the current file"; the agent processes the request, performs tool calls, and updates the client’s file.

Key steps demonstrated:

Capability and session declaration – Enumerating basic (text prompt) and extended capabilities (image, embedded content).

Establishing a bidirectional pipe – Using StdioTransport for communication.

Out‑of‑process invocation – Calling createProcessStdioTransport to launch the Gemini CLI.

Running effect – The agent modifies the code file as requested, proving the workflow works.

8. Ecosystem Value of ACP

ACP benefits IDE vendors (simplified exposure of core features), agent developers (reduced plugin maintenance), and end‑users (seamless tool integration across IDEs).

9. Beyond Code Generation: Future JetBrains AI Features

EmbArk – Massive source‑code context engine : Generates concise description files for each source file during CI, enabling efficient local RAG.

ReCap – AI‑enhanced Local History : Uses AI to summarize recent development activity, helping developers recall work after breaks.

Ask Settings – Natural‑language IDE configuration : An agent interprets user requests (e.g., "set Java code style to Google") and invokes the IDE's Setting API safely.

10. Conclusion

JetBrains' AI journey evolved from isolated plugins to a platform‑centric AI IDE, with ACP serving as the connective tissue that decouples agents from the IDE core. Future AI features will deepen integration with debugging, runtime analysis, and massive code context, delivering a comprehensive intelligent development experience.