Devin Desktop Agent Window: ACP Setup and ChatGPT Billing

For the refreshed Devin Desktop Agent Window, install the current stable build and check the edit-review defaults before running several agents. Use native Devin sessions for ChatGPT token sharing; use ACP when you want a separate coding agent with its own provider account and billing. As of 2026-10-25, the stable changelog lists v3.11.216, following the v3.11.212 redesign released on October 23.

Get the app from the official Devin Desktop download page. The October 24 patch restores local-session access for members whose organization role lacks Cloud-session permission, so there is a practical reason to install it instead of stopping at the initial refresh. See the versioned release notes.

What changes in the Agent Window?

Keep each session’s files, changes, and terminal beside its conversation, then arrange sessions side by side when you need to compare their progress. The new window shares the web app’s interface for sessions, Automations, Review, Wiki, settings, and the Command Palette.

Drag a sidebar session onto an open session to display up to 8 sessions side by side. That is a viewing limit, not a promise of eight simultaneously running jobs: concurrent execution depends on your plan.

The v3.11.212 release notes identify three useful inspection surfaces:

• Files: browse the local working directory or the Cloud session’s machine.
• Changes: inspect local per-file diffs, including a Since last seen scope.
• Terminal: use the session’s add-tab menu to open a shell in its local folder or on its Cloud machine.

For a bug fix, start one implementation session and a second investigation session. With Devin Local, choose New worktree in the location selector for an isolated checkout; the Devin Local guide documents that option. Have the investigation session identify the relevant test while the implementation session changes the code, then review the diff and run that test in the correct session’s terminal.

Side-by-side display helps you supervise work; separate worktrees keep two writers from editing the same checkout. If you only need one small edit, a single session avoids the coordination overhead.

Which settings should Windsurf users check first?

Check inline review, automatic file opening, and save actions before your first editing task. Windsurf’s transition to Devin Desktop was announced on June 2; the October refresh changes behavior beyond the name.

Open Devin User Settings from the Command Palette: Cmd+Shift+P on macOS or Ctrl+Shift+P on Windows/Linux. Use this migration checklist:

Setting	Behavior in the refresh	What to do
Agent diff zones	Off by default; edits apply directly to files	Enable Devin Settings → Editor → User Interface → Agent diff zones if you rely on inline accept/reject review.
Auto-open edited files	Edited files no longer open automatically in the background	Enable Auto-open edited files under Editor → User Interface if that was your review cue.
Save actions on agent edits	Agent saves skip format-on-save and code actions	Enable Run save actions on agent edits if your workflow requires those actions after agent edits.

The advanced settings guide explains the inline accept/reject controls, but its default-on wording conflicts with the October release notes. Check the actual toggles in your installation. With inline review disabled, inspect Changes before committing; with save actions disabled, run your project’s formatter or lint command explicitly when required.

Message delivery also changed: Enter steers the running turn, while Cmd/Ctrl+Enter queues your message until the turn finishes. Use the queued form for follow-up work that should wait.

If you are also moving from Cascade to Devin Local, run Devin: Open Cascade Migration Wizard. Its migration guidance directs workflows and important memories into skills; retained editor settings do not by themselves recreate that agent context.

How do you enable an ACP agent?

Install and authenticate the agent, add its launch entry to the registry, then enable it in Devin Desktop. ACP—the Agent Client Protocol—defines the editor-to-agent connection; it does not supply model credits.

Devin’s ACP documentation lists Codex CLI, Claude Agent, OpenCode, Junie, and Gemini CLI. Access is available on Pro, Max, and Teams; Enterprise administrators must contact their account team about enablement. The public ACP registry includes adapters as well as native implementations, so select the appropriate ACP entry rather than assuming an ordinary CLI launch command is sufficient.

External agents perform their own operations, with billing directly through their providers. Devin explicitly excludes those operations from its own privacy policy and legal terms. Review the chosen agent’s data handling and account configuration; Devin’s ChatGPT-sharing switch should not be treated as the billing control for an external ACP session.

Prepare OpenCode and its provider account

This example uses OpenCode V1 1.19.4 on macOS Apple Silicon, matching its published ACP registry entry. It assumes Node.js and npm are already installed. OpenCode V1 and V2 share the opencode command, so if you already use V2, retain that installation and use its corresponding registry entry instead of installing V1 over it.

Following the V1 installation instructions with an explicit version pin, run these commands in Bash:

npm install -g opencode-ai@1.19.4
opencode --version
opencode auth login
opencode auth list
command -v opencode

Complete the interactive login for the provider you intend to use. The version check should report 1.19.4; auth list should show the configured provider, and command -v should identify the installed executable. The CLI reference documents these authentication commands. A stored credential is only a preparation check—the conversation below verifies that a model request succeeds.

Register, enable, and verify the agent

Use Open Local ACP Registry Config from the Command Palette. The stable macOS/Linux file is ~/.windsurf/acp/registry.json; Windows uses %USERPROFILE%\AppData\Roaming\Code\User\acp\registry.json.

For a new registry on macOS Apple Silicon, use the following JSON. If you already have entries, add the agent object to the existing agents array:

{
  "version": "1.0.0",
  "agents": [
    {
      "id": "opencode",
      "name": "OpenCode",
      "version": "1.19.4",
      "description": "OpenCode via ACP",
      "repository": "https://github.com/anomalyco/opencode",
      "website": "https://opencode.ai",
      "license": "MIT",
      "license_url": "https://github.com/anomalyco/opencode/blob/dev/LICENSE",
      "distribution": {
        "binary": {
          "darwin-aarch64": {
            "archive": "https://github.com/anomalyco/opencode/releases/download/v1.19.4/opencode-darwin-arm64.zip",
            "cmd": "opencode",
            "args": [
              "acp"
            ]
          }
        }
      }
    }
  ]
}

The version and archive address come from the official registry data. Devin currently expects the binary to be installed already and does not download the archive. Here, cmd launches the installed executable, and args selects the opencode acp interface.

For another operating system or architecture, use the matching platform block from the registry. If the desktop process cannot find opencode, replace cmd with the actual absolute path returned by command -v opencode.

Enable it through Devin User Settings → Agents → OpenCode, then restart Devin Desktop. Start a conversation in a trusted repository and select OpenCode in the lower-right agent selector. Send:

Read the project README and summarize its purpose in three bullets. Do not edit files or run shell commands.

Success means the selected agent starts without launch or authentication errors and returns a summary that matches the repository. If authentication fails, repeat opencode auth login for the intended provider; if every agent is unavailable, check whether the workspace is in Restricted Mode. Only trust repositories you intend to let agents access.

For a team, distribute reviewed entries through the ACP Registry Config team setting. A registry entry gives the client launch instructions; it does not establish that the agent uses the same permissions, model settings, or billing account as Devin Local.

What does ChatGPT token sharing cover?

Token sharing covers eligible GPT requests in native Devin sessions you own. As of 2026-10-25, you need ChatGPT Go, Plus, or Pro together with Devin Pro, Max, or Teams; Devin Free and Enterprise are excluded. These conditions come from the current Devin billing guide, and OpenAI lists Devin as a participating app.

Teams users also need a seat with Desktop access: full seats include it; flex seats do not. Each member links their own ChatGPT account.

To connect and verify it:

1. Open Settings → Connections, choose Continue with ChatGPT, and authorize plan usage.
2. In the Desktop model picker, enable Use your ChatGPT plan. This account-wide switch also affects Cloud and CLI.
3. Select a covered GPT model in a native Devin session. From Settings → Usage & limits, follow Manage usage to check the ChatGPT-funded consumption.

Desktop keeps your selected model. Turning on sharing therefore does not convert a non-GPT selection into a covered GPT request.

Work being performed	Billing route with sharing enabled and available
Eligible GPT requests in your native Devin sessions	ChatGPT plan
Non-GPT requests, including other models used by local Fusion	Devin quota or on-demand credits
Fast or priority GPT variants	Devin quota or on-demand credits
Cloud machine time and code scans	Devin quota or on-demand credits
Sessions you do not own, including automations that do not run as you	Not covered by your linked ChatGPT plan; Devin billing applies
External ACP agent operations	That agent’s provider/account arrangement

Cloud sessions still require available Devin quota or credits to start. In local Fusion, only the eligible GPT portion moves to ChatGPT, so a mixed-model workflow leaves part of its usage on Devin.

How long will ChatGPT Plus last, and what happens at the limit?

Measure your own task consumption before planning around Plus. OpenAI’s usage guidance says an allowance does not translate into a fixed number of tasks: model, context, task, and settings affect it. There is no sound conversion from a subscription’s reset window into guaranteed hours of Devin work.

Connected-app requests draw from your existing ChatGPT Work and Codex allowance. In ChatGPT, use Settings → Usage → App limits → Manage limits for Devin to set its weekly percentage cap. This limits its share of usage without reserving an extra pool. Optional ChatGPT-credit use is a separate permission, off by default, and requires the app limit to be 100%; see OpenAI’s connected-app controls.

Treat ChatGPT sharing as a billing route, not a guarantee that Devin spending stops. Devin documents different limit behavior: Desktop and CLI retry on Devin quota, then on-demand credits, whereas Cloud pauses until the allowance resets or you disable sharing and resume.

There is a documentation conflict here: OpenAI’s general connected-app guidance says unavailable plan usage or credits will not automatically switch an app to another paid option. Because Devin explicitly documents local fallback, assume Devin charges remain possible and verify the notice and usage in your account before leaving jobs unattended.

If Devin shows ChatGPT plan disabled, choose Reconnect and verify that sharing is enabled. Devin says GPT requests use Devin billing while the ChatGPT authorization is expired or revoked.

Inspect your remaining quota and credit balance in Devin Usage & limits. Administrators should also review auto-reload and default session spending limits, which Devin describes in its self-serve billing controls. A ChatGPT app cap does not establish a cap on these separate Devin charges.

For a useful first measurement, record both usage displays, run one bounded task, and check them again. Use the same repository, model, and scope when comparing another run. Expand to parallel sessions only after you can identify where the consumption landed and how you will review the resulting changes.