# How to Connect and Run Devin AI in IntelliJ IDEA and JetBrains IDEs

The Devin IntelliJ integration connects Cognition's AI software engineer to JetBrains IDEs through the Agent Client Protocol (ACP). Developers can install Devin from the JetBrains ACP Registry or configure a local CLI binary inside acp.json to prompt, inspect, and guide the agent from the native AI Chat tool window. This setup supports local development environments as well as JetBrains Remote Development backends.

Source: https://fast.io/resources/devin-ai-intellij/
Last reviewed: 2026-09-04

## Agent Client Protocol Architecture in JetBrains IDEs

Historically, software engineers treated autonomous coding agents as cloud-only tools confined to browser sandboxes. Running an agent meant opening a web dashboard, waiting for a remote execution loop, and pulling git commits back down to inspect code locally. The integration between Cognition's Devin AI and JetBrains IDEs removes that separation by using the [Agent Client Protocol (ACP)](https://agentclientprotocol.com/) to embed Devin directly inside IntelliJ IDEA, PyCharm, GoLand, WebStorm, and other JetBrains development environments.

The Devin IntelliJ integration connects Cognition's AI software engineer to JetBrains IDEs using the Agent Client Protocol (ACP), allowing developers to prompt, guide, and review Devin directly within the AI Chat tool window.

Understanding this connection requires looking closely at ACP itself. The Agent Client Protocol is an open standard created to decouple code editors from autonomous agent backends. Rather than relying on simple text completions or rigid proprietary extensions, ACP defines a structured communication contract. Under the hood, the JetBrains AI Assistant plugin serves as the host client, spawning or attaching to the Devin agent process and communicating over standard input and output streams using JSON-RPC, as documented in [Cognition's official JetBrains integration guide](https://docs.devin.ai/cli/acp/jetbrains.md).

Through this stdio JSON-RPC bridge, Devin streams thought sequences, requests tool permissions, announces file edits, and reports command execution results directly to IntelliJ IDEA. Developers see progress unfold inside the native AI Chat panel without context switching to an external browser tab.

### Differences Between Web Sandboxes and IDE Subprocesses

Many early tutorials assume Devin operates only within Cognition's hosted virtual machine. In that traditional model, Devin provisions an ephemeral cloud container with its own browser, terminal, and code editor. Developers interact through a web interface, and completed work is delivered by pushing a branch to GitHub or GitLab.

The ACP integration introduces an alternative execution model. When running Devin inside IntelliJ IDEA through ACP, the agent operates in direct conversation with your editor environment. Devin can read project files from your active project root, propose targeted changes that render within IntelliJ diff viewers, and register custom slash commands directly in the AI Chat input palette.

This architectural shift allows developers to guide Devin interactively. If Devin proposes an architectural change that conflicts with your local conventions, you can interject immediately in AI Chat rather than waiting for an entire cloud session to conclude.

### Prerequisites for IntelliJ IDEA and JetBrains IDEs

Before setting up Devin, verify that your environment meets the necessary software requirements:

* **Supported JetBrains IDE:** IntelliJ IDEA (Ultimate or Community), PyCharm, GoLand, WebStorm, CLion, or Rider running version `2024.2` or newer.
* **AI Assistant Plugin:** Ensure the official JetBrains AI Assistant plugin is installed and activated. The plugin provides the AI Chat tool window and the underlying ACP host implementation.
* **Active Devin Account:** You need valid Cognition credentials with access to Devin CLI capabilities.
* **Operating System Support:** macOS, Linux, or Windows (via `WSL2` or native PowerShell when running the local CLI binary).

## How to Connect Devin AI in IntelliJ IDEA via the ACP Registry

The quickest way to connect Devin AI to IntelliJ IDEA is through the JetBrains ACP Registry. JetBrains AI Assistant maintains a catalog of verified agent definitions, eliminating the need to install local binaries or configure configuration files manually.

Follow these steps to complete the registry installation:

1. **Open AI Chat:** Click the **AI Chat** tool window icon located in the right-hand tool window bar of IntelliJ IDEA.
2. **Open the Agent Selector:** In the footer bar of the AI Chat panel, click the agent selector dropdown, which displays your current default model or agent.
3. **Install from ACP Registry:** Click **Install From ACP Registry...** from the selector menu.
4. **Search and Install Devin:** Type `Devin` into the search bar, locate the official Devin entry from Cognition, and click **Install**. IntelliJ IDEA registers the agent configuration immediately.
5. **Authenticate with Devin:** When you initiate your first prompt or select Devin, a prompt will appear requesting authentication. Complete the browser-based sign-in to connect your Cognition account.
6. **Start an Agent Session:** Select **Devin** from the agent selector and send your instructions to begin the session.

### Reviewing Diffs and Tool Actions in AI Chat

Once connected through the ACP Registry, Devin renders session progress directly inside the AI Chat timeline. When Devin analyzes a codebase to resolve an issue, you will observe distinct stages:

* **Reasoning and Planning:** Devin articulates its architectural strategy and identifies candidate files for modification.
* **Shell Execution:** Command invocations, such as running test runners or dependency checks, appear inside collapsible terminal blocks within the chat interface.
* **Structured Diffs:** When Devin modifies source files, JetBrains presents native file diffs. You can click on any modified file to view side-by-side comparisons, review line additions, and inspect deletions before committing the changes.

## How to Configure a Custom Devin Agent via acp.json

While the ACP Registry provides convenient one-click installation, certain enterprise workflows require running a specific local Devin CLI binary. For example, teams using custom wrapper scripts, internal proxy layers, pinned binary versions, or offline staging environments often prefer manual configuration.

JetBrains AI Assistant stores custom agent definitions in a central configuration file named `acp.json`. You can configure Devin as a local stdio agent server by referencing your installed `devin` binary.

First, verify that the Devin CLI is installed on your workstation. Run the following installation command in your terminal:

```bash
curl -fsSL https://cli.devin.ai/install.sh | bash
```

After the installer completes, authenticate your local installation:

```bash
devin auth login
```

Next, identify the absolute path to your `devin` executable by running `which`:

```bash
which devin
```

On most Linux and macOS systems, this command outputs `/usr/local/bin/devin` or a user path like `/home/username/.local/bin/devin`. Copy this absolute path.

### Defining the Agent Server in acp.json

To add Devin manually to IntelliJ IDEA, open `acp.json` from within the editor:

1. Open the **AI Chat** panel from the right tool window bar.
2. Click the three-dots menu in the top-right corner of the AI Chat header.
3. Select **Add Custom Agent**. IntelliJ IDEA automatically opens your user-level `acp.json` file in the main editor.

Add Devin to the `agent_servers` block. Ensure `command` points to your absolute binary path, and provide `"acp"` as the single argument:

```json
{
  "default_mcp_settings": {},
  "agent_servers": {
    "devin": {
      "command": "/home/username/.local/bin/devin",
      "args": ["acp"]
    }
  }
}
```

Save `acp.json`. IntelliJ IDEA will parse the updated JSON structure immediately, and `devin` will appear as a selectable option in the AI Chat agent dropdown.

Note that the `devin acp` subcommand is designed specifically as a background subprocess. If you execute `devin acp` directly in your terminal, the process will appear to hang because it expects an ACP host communicating over standard input.

### Managing Session Authentication and Credentials

When you launch the custom agent, Devin uses the local credentials generated during `devin auth login`. If your authentication expires or you switch Devin accounts, use the three-dots menu in the AI Chat panel to execute **Reset ACP Authentication**. This action clears cached session state and prompts for a fresh login.

For debugging connection problems, click **Get ACP Logs** from the same three-dots menu. IntelliJ IDEA opens a dedicated log stream showing the raw JSON-RPC requests and responses exchanged between the IDE and the Devin process.

## How to Run Devin in JetBrains Remote Development Environments

Many engineering teams develop on remote cloud instances, virtual machines, or high-performance build servers rather than local hardware. [JetBrains Remote Development](https://www.jetbrains.com/remote-development/) splits the IDE into two halves: a headless IDE backend running on the remote host (via SSH or JetBrains Gateway) and a lightweight client running on your local machine.

A common configuration mistake occurs when developers install the Devin CLI locally and expect the remote JetBrains session to detect it. In JetBrains Remote Development, the AI Assistant plugin and the AI Chat host process run on the **remote server**, not your local laptop. Because ACP communicates over stdio JSON-RPC directly with the host process, JetBrains cannot invoke a binary located on your client machine. The CLI binary, authentication cache, and project dependencies must all exist on the remote host where the IDE backend executes.

### Remote Host CLI Installation and Configuration

To run Devin across a remote SSH backend, configure the host environment directly on the server:

1. Connect to the Remote Server: Open an SSH terminal session into the remote host where your code and JetBrains backend reside.
2. Install the Devin CLI on the Remote Machine: Run the installation command `curl -fsSL https://cli.devin.ai/install.sh | bash` directly on the remote server.
3. Authenticate on the Remote Host: Execute `devin auth login` in the remote SSH shell and complete authentication.
4. Locate the Remote Path: Run `which devin` on the remote server and record the resulting path, such as `/home/ubuntu/.local/bin/devin`.
5. Configure Remote acp.json: In your JetBrains Gateway client window, open AI Chat, select **Add Custom Agent**, and enter the remote absolute path into the `acp.json` configuration file.

Because the remote backend spawns the process, the remote path ensures that JetBrains launches Devin in the exact environment where your compilers, build dependencies, and source trees are located.

### Handling Permissions and Background Services

When configuring remote servers, verify that the remote user running the JetBrains backend process has execution permissions for the `devin` binary (`chmod +x /path/to/devin`).

If your remote host restricts outbound internet access through corporate proxy servers, ensure standard environment variables such as `HTTP_PROXY` and `HTTPS_PROXY` are exported in the remote shell profile so Devin can communicate with Cognition's cloud infrastructure.

## Why Engineering Teams Need Persistent Workspaces for Devin Deliverables

Integrating Devin into IntelliJ IDEA streamlines local code generation and refactoring. However, software engineering extends beyond modifying repository files. Autonomous agents generate extensive non-code deliverables: architectural summaries, migration playbooks, database seed dumps, API specifications, client deployment guides, and integration test logs.

Leaving these deliverables on a developer's local laptop or an ephemeral remote VM creates context fragmentation. Teammates who do not run IntelliJ IDEA cannot access the outputs, and client stakeholders cannot review technical assets without repository access.

Engineering teams often attempt to solve this with raw cloud storage buckets or commodity file drives. Storing agent outputs in raw Amazon S3 buckets requires configuring custom IAM roles, bucket policies, and manual download links, providing no native document search or team collaboration features. Basic consumer cloud drives sync files for human desktop browsing but lack agent-ready protocols, programmable metadata extraction, and multi-agent coordination.

[Fast.io persistent agent workspaces](/product/workspaces/) bridge this gap by providing an intelligent cloud workspace platform for agentic teams. Instead of scattering deliverables across local disks, agents and developers collaborate within shared, org-owned workspaces backed by per-file version history and granular access permissions. Learn more about [Fast.io storage for agents](/storage-for-agents/) and how teams coordinate multi-agent software development.

### Connecting Devin and Team Workspaces via MCP

Fast.io exposes a consolidated Model Context Protocol server accessible via Streamable HTTP at `https://mcp.fast.io/mcp` (or `https://mcp.fast.io/mcp/key` when using Bearer authentication). Autonomous agents like Devin can interact with shared workspaces directly through standard MCP tooling documented in the [Fast.io storage for agents guide](/storage-for-agents/):

* **Persistent File Writes:** When Devin completes a complex refactoring task in IntelliJ IDEA, it can deposit the resulting deployment manifests, architectural diagrams, and migration summaries directly into a Fast.io workspace.
* **Per-File Version History:** Every file uploaded preserves complete revision tracking, allowing teams to audit changes, compare diffs, and restore prior versions if multiple agents or team members collaborate simultaneously.
* **Real-Time Intelligence Mode:** Files uploaded to a Fast.io workspace are automatically indexed for hybrid search (combining full-text, semantic meaning, and metadata values). Developers and agents can query the workspace using natural language to retrieve technical answers with exact document citations.

### Structuring Deliverables and Sharing with Stakeholders

Beyond simple storage, Fast.io includes [Metadata Views](/product/document-data-extraction/), transforming unstructured technical documents into queryable tables. When Devin uploads dozens of test reports, security audit summaries, or schema definitions, Metadata Views automatically extract structured fields such as test pass rates, target endpoints, and completion dates without manual rule configuration.

When deliverables are ready for client presentation or cross-functional review, teams can generate branded shares (Send, Receive, or Exchange) or durable File Shares. These shares provide secure, link-based access with custom expiration dates and recipient-level permissions. Clients review polished project portals without needing repository access or IntelliJ licenses.

Fast.io operates on a transparent subscription model. Every organization begins with a `14-day` free trial, which requires a credit card. Paid subscription plans include Starter at `$29/mo`, Business at `$99/mo`, and Growth at `$299/mo`, giving teams scalable storage, intelligent search, and multi-seat collaboration. Explore plan details on the [Fast.io pricing page](/pricing/).

## How to Troubleshoot JetBrains ACP and Devin Connection Failures

When connecting autonomous agents to IDE environments through protocol bridges, configuration mismatches and network constraints can disrupt communications. JetBrains AI Assistant provides diagnostic surfaces specifically designed to troubleshoot Agent Client Protocol connections.

If Devin fails to connect, drops mid-session, or produces unexpected error prompts inside IntelliJ IDEA, use the following systematic checklist to isolate and resolve the underlying failure before recreating configuration files or reinstalling plugins. In many instances, connection issues stem from simple environmental differences between your interactive terminal and the subprocess shell spawned by IntelliJ IDEA. Verifying executable permissions, confirming absolute binary paths, and reviewing raw JSON-RPC log streams allow you to pinpoint exact handshake failures quickly.

### Agent Process Fails to Start

If AI Chat displays an error stating that the agent server failed to launch, check your `acp.json` configuration:

* **Verify Absolute Paths:** Ensure the `command` attribute specifies a complete absolute path (such as `/usr/local/bin/devin`) rather than a relative path or alias.
* **Verify File Permissions:** Confirm that the binary has executable permissions by running `ls -l /path/to/devin` in your terminal. If necessary, execute `chmod +x /path/to/devin`.
* **Verify Stdio Compatibility:** Do not pass interactive flags in `args`. The array should contain only `["acp"]`.

### Authentication Timeouts and Stale Credentials

If Devin prompts repeatedly for authentication or requests fail with authorization errors:

1. Open the AI Chat panel in IntelliJ IDEA.
2. Click the three-dots menu in the upper-right corner.
3. Select **Reset ACP Authentication**.
4. Switch to your system terminal and execute `devin auth login` to verify your Cognition account status directly.
5. Re-select Devin in AI Chat to initiate a clean session.

### Inspecting ACP Communication Logs

When unexpected errors occur during code generation, inspect the raw protocol traffic. Click the three-dots menu in AI Chat and select **Get ACP Logs**.

Review the stream for JSON-RPC error frames. Standard errors typically indicate missing file paths, environment variable mismatches, or network timeouts when contacting Cognition's infrastructure.

## Frequently asked questions

### Can I use Devin AI inside IntelliJ IDEA?

Yes. Cognition supports running Devin inside IntelliJ IDEA and other JetBrains IDEs using the Agent Client Protocol (ACP). Developers can install Devin directly through the JetBrains ACP Registry or configure a local Devin CLI installation in acp.json to run Devin from the AI Chat tool window.

### How do I install Devin from the JetBrains ACP Registry?

To install Devin from the registry, open the AI Chat tool window in the right-hand bar of your JetBrains IDE. In the footer of the AI Chat panel, click the agent selector dropdown, choose Install From ACP Registry..., search for Devin, and click Install. Once installed, select Devin in the dropdown to authenticate and start chatting.

### Does Devin support JetBrains Remote Development?

Yes. Devin supports JetBrains Remote Development, but the Devin CLI binary and authentication must be set up on the remote host where the backend runs, rather than on your local client machine. Install the CLI on the remote server, run devin auth login, obtain the path with which devin, and enter that path in acp.json.

### What is the Agent Client Protocol (ACP) used by Devin in JetBrains?

The Agent Client Protocol (ACP) is an open communication standard that connects external autonomous AI agents to code editors and IDEs. In JetBrains IDEs, ACP runs over stdio JSON-RPC, enabling AI Assistant to stream Devin's thoughts, trigger shell actions, surface slash commands, and present structured file diffs directly in the editor.

### Why does running devin acp in the terminal produce no output?

The devin acp command is a background subprocess intended to communicate with an ACP-compatible host client like JetBrains AI Assistant. Because it exchanges structured JSON-RPC messages across standard input and output streams, running it directly in an interactive terminal will appear idle as it waits for incoming host packets.

### How can teams share non-code deliverables produced by Devin?

While git tracks code changes, non-code artifacts like architecture diagrams, migration summaries, and compliance logs are best preserved in a shared intelligent workspace. Platforms like Fast.io provide version-controlled workspaces with remote MCP access, semantic file indexing, and branded share links for team and client distribution.

## About Fast.io

Fast.io provides shared workspaces where people and AI agents work on the same files, with built-in semantic search and citation-backed chat over what they hold. Agents reach it through a remote MCP server at https://mcp.fast.io/mcp, a REST API at https://api.fast.io/current/, and a command line client published on npm as @vividengine/fastio-cli.