OpenClaw JetBrains Plugin: Setup Guide for IntelliJ, PyCharm, WebStorm, and GoLand

Only 22% of developers use AI coding agents in their daily work, even though 66% of companies plan to adopt them within the next year, per the JetBrains AI Pulse survey of 11,000 developers in January 2026. JetBrains IDE users make up a significant chunk of that incoming wave, but most agent setup guides still assume VS Code.

OpenClaw is an open-source AI agent that runs on your machine and connects large language models to real development tools. Unlike chatbots that suggest code snippets, OpenClaw reads files, runs shell commands, browses the web, and executes multi-step tasks. The JetBrains plugin brings this directly into IntelliJ IDEA, PyCharm, WebStorm, GoLand, and every other JetBrains IDE through the Agent Client Protocol (ACP).

ACP is an open standard developed by JetBrains and Zed that defines how IDEs and AI coding agents communicate. It removes the need for one-off integrations: any ACP-compatible agent works in any ACP-compatible editor. OpenClaw's ACP mode acts as a bridge, speaking the ACP protocol over stdio to the IDE and forwarding prompts to the OpenClaw Gateway over WebSocket.

The plugin itself adds a status bar launcher so you can start and interact with OpenClaw without leaving your editor. Behind the scenes, the ACP bridge maintains session mappings, so your conversations persist across IDE restarts. The plugin is free, the SDK stabilized with the v2026.3.23-2 release, and you do not need a JetBrains AI subscription to use it.

This guide walks through installation, configuration, remote gateway connections, and troubleshooting for every major JetBrains IDE.

Before you start, you need three things: a JetBrains IDE (Community Edition works), OpenClaw installed on your machine, and a running OpenClaw Gateway instance, either local or remote.

There are two installation paths, and both land you at the same place.

From the JetBrains Marketplace

1. Open your IDE and go to Settings (Ctrl+Alt+S on Windows/Linux, Cmd+Comma on macOS)
2. Select Plugins from the left sidebar
3. Click the Marketplace tab
4. Search for "OpenClaw"
5. Click Install on the OpenClaw plugin
6. Restart the IDE when prompted

The official plugin lives at plugins.jetbrains.com/plugin/31531-openclaw.

From the ACP Registry

1. Open the AI Chat tool window in your IDE
2. Click the mode selector dropdown
3. Select "Install From ACP Registry"
4. Find OpenClaw in the list and click Install
5. The IDE handles the download and runtime setup automatically

The ACP Registry approach is slightly faster because the IDE manages the executable path and runtime dependencies for you. The Marketplace approach gives you the same plugin but requires manual acp.json configuration, which the next section covers.

After either installation path, you will find an OpenClaw entry in Settings, then Tools, then AI Assistant, then Agents. You do not need a JetBrains AI subscription to use ACP agents. This is free functionality built into the IDE's agent infrastructure.

If your organization restricts plugin installations, ask your admin to allowlist the OpenClaw plugin ID or distribute the acp.json configuration through your team's dotfiles.

After installing the plugin, you need to tell it where your OpenClaw Gateway is running. ACP agents in JetBrains IDEs are configured through a JSON file that maps agent names to executable paths and connection arguments. The official plugin page documents the current file location and schema.

For a local Gateway, the configuration points to your OpenClaw executable and passes the acp argument to start in ACP bridge mode. You can optionally expose your personal MCP servers to the agent, which is useful if you want OpenClaw to access tools like the Fast.io MCP server or other endpoints you have configured.

Refer to the official plugin page and the OpenClaw documentation for the exact JSON structure and available fields, as these may change between releases.

For a remote Gateway, add the URL and authentication to the args array:

{
  "agent_servers": {
    "OpenClaw Remote": {
      "command": "/usr/local/bin/openclaw",
      "args": [
        "acp",
        "--url", "wss://gateway-host:18789",
        "--token-file", "/home/user/.openclaw/gateway.token"
      ]
    }
  }
}

Use --token-file instead of --token to keep credentials out of process listings. The official OpenClaw documentation recommends this approach for any setup where other users share the machine.

To pin your IDE to a specific Gateway session so context persists across restarts:

"args": ["acp", "--session", "agent:main:main"]

After saving acp.json, restart the IDE. Open AI Chat and select OpenClaw from the agent dropdown. The status bar indicator should appear in the bottom panel.

Give your OpenClaw agents persistent file storage

Fast.io's workspace includes storage, monthly credits, and an MCP server your agents can access from any JetBrains project. Starts with a 14-day free trial.

Start 14-Day Trial

Running OpenClaw against a remote Gateway gives you access to agents on more powerful hardware while keeping your local IDE lightweight. The tradeoff is slightly higher latency, but remote agents retain persistent memory and project-specific knowledge that local-only setups lack.

Setting Up the SSH Tunnel

If your Gateway runs on a remote server, create an SSH tunnel to forward traffic securely:

ssh -N -L 28789:127.0.0.1:18789 user@your-server-ip

This maps local port 28789 to the Gateway's default port (18789) on the remote machine. Keep this terminal session open during your coding session.

Then update your acp.json args to point at the tunnel:

"args": ["acp", "--url", "ws://127.0.0.1:28789", "--token-file", "~/.openclaw/gateway.token"]

Securing Your Gateway Token

Store your Gateway token in a dedicated file with restricted permissions:

echo "your-token-here" > ~/.openclaw/gateway.token
chmod 600 ~/.openclaw/gateway.token

You can also set the OPENCLAW_GATEWAY_TOKEN or OPENCLAW_GATEWAY_PASSWORD environment variable in your shell profile or in the env block of acp.json.

Enterprise Proxy and SSO Considerations

For teams behind corporate proxies, OpenClaw respects standard HTTPS_PROXY and HTTP_PROXY environment variables. Set these in the env block of your acp.json or at the system level.

For SSO-managed tokens, the environment variable approach works well with corporate secrets managers. Your IT team can rotate tokens without touching individual developer configurations.

One security detail worth noting: ACP sessions run on the host system, not inside a sandbox. The external agent operates under its own CLI permissions and the working directory you specify. Keep this in mind when granting file system access in enterprise environments.

OpenClaw agents produce files throughout a coding session: code patches, research notes, configuration templates, generated tests. On a single developer's machine, these scatter across project directories. When you switch computers, pair with a colleague, or hand work off to a client, that output often gets lost.

A persistent workspace gives agent output a home. You have several options depending on your workflow.

Git repositories handle code well, but they add friction for binary artifacts and lack semantic search. Cloud storage services like S3, Google Drive, or Dropbox store files but do not expose agent-native interfaces, so your OpenClaw agent cannot upload or organize files without custom scripting.

Fast.io takes a different approach. It exposes an MCP server with 19 tools that agents can call directly, so your OpenClaw agent can upload outputs, organize workspaces, and create branded share links without leaving the ACP session. When Intelligence Mode is enabled, uploaded files are automatically indexed for semantic search and AI-powered chat with citations.

A practical workflow looks like this: your OpenClaw agent in IntelliJ generates a code review document, uploads it to a Fast.io workspace via MCP, and shares a branded link with your team lead. The team lead reviews it in their browser without needing OpenClaw or the IDE. When the project wraps up, workspace ownership transfers from the agent to the human, and the agent retains admin access for future updates.

Plans bundle storage, monthly credits, and workspaces scaled to each tier, and every org starts with a 14-day free trial. You connect it by adding the Fast.io MCP server to your IDE's MCP configuration alongside the OpenClaw ACP agent.

Most installation issues fall into a few categories. Here is what to check for each one.

"Backend not configured" or "ACP is disabled"

The OpenClaw ACP backend needs to be explicitly enabled. Run /acp doctor in your OpenClaw Gateway to verify readiness. If the acpx plugin is missing, install and enable it:

openclaw plugins install @openclaw/acpx
openclaw config set plugins.entries.acpx.enabled true

Agent Not Appearing in the IDE

Confirm your acp.json is valid JSON and lives at ~/.jetbrains/acp.json. A misplaced comma or bracket will silently prevent the agent from loading. Test the OpenClaw executable path by running it directly in a terminal. If you installed via the ACP Registry, check Settings, then Tools, then AI Assistant, then Agents for update notifications. A blue dot appears when updates are available.

Connection Timeouts with Remote Gateways First confirm your SSH tunnel is active. Then test the connection manually with the built-in ACP debug client:

openclaw acp client --server-args --url wss://gateway-host:18789 --token-file ~/.openclaw/gateway.token

This spawns an interactive session for protocol validation without needing the IDE. If the debug client connects but the IDE does not, the issue is in your acp.json configuration rather than the network.

Collecting Diagnostic Logs Open the AI Chat window in your IDE and click "Get ACP Logs" to export a log bundle. For more detailed output, enable llm.agent.extended.logging in the IDE Registry (Help, then Find Action, then search for "Registry"). This captures full request and response data for every ACP exchange.

Known Platform Limitation WSL (Windows Subsystem for Linux) is not currently supported for ACP agents in JetBrains IDEs. If you run OpenClaw inside WSL, configure it as a remote gateway instead and connect through localhost port forwarding using the SSH tunnel approach described earlier.