Skip to content

JetBrains IDEs (AI Assistant plugin, IntelliJ IDEA / PyCharm / WebStorm / full IDE family) ​

Produced by the ACP product case-study pass (2026-07-30), then adversarially verified; corrections below override the body where they conflict.

JetBrains IDEs as an ACP Client ​

JetBrains implements the Agent Client Protocol natively, as the client (IDE) side, not as an agent and not via a third-party adapter. This is a strategic pivot: JetBrains and Zed Industries agreed to unify around one protocol rather than compete, and JetBrains is now a co-developer of ACP, not just a consumer (https://zed.dev/blog/jetbrains-on-acp). The mechanism is the JetBrains AI Assistant plugin, which since the 25.3 release-candidate cycle (December 2025) ships beta "bring your own agent" support (https://blog.jetbrains.com/ai/2025/12/bring-your-own-ai-agent-to-jetbrains-ides/), and as of AI Assistant 253.30387.147 on IDE build 2025.3.2+ also ships an ACP Agent Registry browser shared with Zed (https://blog.jetbrains.com/ai/2026/01/acp-agent-registry/). The support spans "IntelliJ IDEA, PyCharm, and the full IDE family" per JetBrains' own ACP landing page (https://www.jetbrains.com/acp/). A separate, community-maintained plugin (github.com/zekariasasaminew/jetbrains-acp) also exists for users who want ACP without the AI Assistant plugin, but JetBrains' own integration is the one that matters for trogonai's design questions.

Integration wiring is subprocess-based. Custom agents are declared in ~/.jetbrains/acp.json under an agent_servers map, each entry giving a command, args, and environment variables; the IDE spawns the agent, downloading a Node.js or Python runtime automatically if the agent needs one (https://www.jetbrains.com/help/ai-assistant/acp.html). This mirrors ACP's canonical transport: JSON-RPC 2.0 over stdin/stdout, with protocolVersion (currently integer 1) negotiated during initialize (https://agentclientprotocol.com/protocol/initialization). JetBrains explicitly does not support this under WSL. MCP server passthrough is configurable in the same acp.json via default_mcp_settings (use_custom_mcp, use_idea_mcp), with idea_mcp_allowed_tools to scope which built-in IntelliJ MCP tools an agent can see. Permission-request and fs/terminal RPC handling are not documented in granular detail publicly; JetBrains' docs describe a "Get ACP Logs" action and an llm.agent.extended.logging registry key for debugging request/response traffic, implying the IDE mediates these RPCs through its own UI rather than exposing raw approval APIs.

The jetbrains/agent-client-protocol GitHub repo is a fork of agentclientprotocol/agent-client-protocol, not a JetBrains-original SDK; the canonical repo publishes a Rust crate (agent-client-protocol) and TypeScript/npm package (@zed-industries/agent-client-protocol) (https://github.com/jetbrains/agent-client-protocol). No public JetBrains material describes technical pushback or spec changes JetBrains forced onto ACP: the blog posts are strategic (why they joined) rather than engineering diffs.

Channel mapping is absent. Everything JetBrains has published scopes ACP to the IDE's own chat/agent panel; there is no mention of Slack, Telegram, WhatsApp, web chat, mobile, or voice fan-out anywhere in JetBrains' ACP documentation.

For trogonai, JetBrains cannot be "hosted" through the ACP boundary the way a spawned coding agent can; JetBrains is the client, meaning trogonai would need to be the thing JetBrains spawns. Concretely, trogonai would register an acp.json entry pointing at its own stdio-native ACP agent entrypoint (the natural job of the existing acp-nats-stdio crate), which speaks stdio JSON-RPC to the IDE while relaying to trogonai's internal NATS-based agent runtime. No new transport work is implied since JetBrains already assumes stdio subprocess as the only supported shape; the effort is packaging, not protocol translation. Inference: the same stdio-subprocess packaging would work unmodified for Zed, since both clients converged on identical wiring.

Design lessons for trogonai: JetBrains' acp.json gives a clean, declarative multi-agent registry pattern (per-agent command/args/env plus scoped MCP passthrough flags) that trogonai's own agent-facing config could copy rather than reinvent. The explicit idea_mcp_allowed_tools allowlist is a good least-privilege pattern for MCP passthrough that trogonai's gateway should consider mirroring. What to avoid: JetBrains ships this as beta with an unsupported-on-WSL carve-out and an undocumented permission/fs RPC surface; trogonai should not assume JetBrains' behavior here is stable or spec-complete enough to design hard dependencies against yet, and should treat the registry's "Agent Auth or Terminal Auth" gate as evidence that ACP's auth story is still being standardized rather than settled.

Sources ​

Adversarial verification ​

  • confirmed: ACP status is native via JetBrains AI Assistant plugin (2025.3.2+/build 253.30387.147+), beta since RC 25.3 (Dec 2025), config at ~/.jetbrains/acp.json, agent picker at Settings | Tools | AI Assistant | Agents, plus third-party plugin github.com/zekariasasaminew/jetbrains-acp (JetBrains blog (blog.jetbrains.com/ai/2025/12/bring-your-own-ai-agent-to-jetbrains-ides) confirms beta ACP in the 25.3 release candidate (Dec 2025); YouTrack issue LLM-24125 and the zekariasasaminew/jetbrains-acp README independently corroborate build 253.30387.147 / IDE 2025.3.2+ as the version gate; jetbrains.com/help/ai-assistant/acp.html and install-acp-agents.html confirm ~/.jetbrains/acp.json and the Settings | Tools | AI Assistant | Agents picker path; the third-party repo exists exactly as described, positioning itself as a subscription-free alternative.)
  • confirmed: Callability verdict is no: JetBrains IDEs are an ACP client that spawns agents, not an ACP agent host trogonai can call into; trogonai would need to expose itself as a stdio subprocess (e.g. via acp-nats-stdio) declared in ~/.jetbrains/acp.json, architecturally identical to how it would expose itself to Zed (agentclientprotocol.com (official spec) confirms the editor is always the ACP client that spawns the agent as a stdio subprocess and owns the connection lifecycle, matching the claimed inversion; direct inspection of trogonai's acp-nats-stdio README confirms this crate already exists and does exactly what the claim describes (stdio-to-NATS JSON-RPC bridge for IDE-spawned clients), supporting the architectural inference as grounded in the real codebase rather than speculative.)
  • confirmed: JetBrains is co-developing ACP with Zed Industries rather than shipping a competing protocol (zed.dev/blog/jetbrains-on-acp states JetBrains approached Zed, 'decided ACP was the right approach,' and will co-develop the protocol and bring it across the full IDE lineup (IntelliJ IDEA, PyCharm, WebStorm).)
  • confirmed: JetBrains AI Assistant supports ACP so users can connect external agents and use AI Chat without a JetBrains AI service subscription (jetbrains.com/help/ai-assistant/acp.html states explicitly that ACP-compatible agents can be used without a JetBrains AI service subscription.)
  • confirmed: Custom ACP agents are configured via ~/.jetbrains/acp.json with agent_servers entries (command, args, env), IDE spawns subprocess, can auto-download Node.js/Python runtimes (jetbrains.com/help/ai-assistant/acp.html and install-acp-agents.html show the exact JSON schema (agent_servers, command, args, env) and confirm automatic runtime download for Node.js/Python.)
  • confirmed: MCP passthrough controlled by default_mcp_settings (use_custom_mcp, use_idea_mcp) with idea_mcp_allowed_tools restricting exposed built-in IntelliJ MCP tools (Direct fetch of jetbrains.com/help/ai-assistant/acp.html returned verbatim JSON keys use_idea_mcp, use_custom_mcp, and idea_mcp_allowed_tools with matching descriptions (use_custom_mcp default true, use_idea_mcp default false).)
  • confirmed: ACP-compatible agents are explicitly not supported under WSL (jetbrains.com/help/ai-assistant/acp.html contains the verbatim sentence: 'Currently, ACP-compatible agents are not supported in the Windows Subsystem for Linux (WSL).')

Released under the Apache License 2.0.