Skip to main content

Overview

You can use Poolside in editors that do not have a native Poolside extension by running pool acp. This Agent Client Protocol (ACP) server works with Zed, JetBrains, Neovim, and other editors that support ACP. If you use VS Code or Visual Studio, use the native Poolside Assistant integration instead of ACP.

Capabilities

Poolside ACP supports the following capabilities when the editor client exposes them:
  • To-do lists
  • Plan mode
  • Skills
  • AGENTS.md
  • Resume saved sessions when the editor supports session history
  • Change modes and models when the editor supports ACP session configuration
  • Configure thought level when the editor supports ACP session configuration
  • Use slash commands, including available skills as slash commands, when the editor supports them

Set up the Zed editor

pool acp setup --editor zed
This writes Poolside agent configuration to ~/.config/zed/settings.json. For more information, see Zed documentation. If you prefer to configure Zed manually, add the following configuration to ~/.config/zed/settings.json:
{
  "agent_servers": {
    "Poolside": {
      "command": "pool",
      "args": ["acp"],
      "type": "custom"
    }
  }
}
After you configure Zed, restart it and select Poolside from the agent picker.

Set up the JetBrains IDE

pool acp setup --editor jetbrains
This writes configuration to ~/.jetbrains/acp.json. For more information, see JetBrains documentation. If you prefer to configure JetBrains manually, add the following configuration to ~/.jetbrains/acp.json:
{
  "agent_servers": {
    "Poolside": {
      "command": "pool",
      "args": ["acp"]
    }
  }
}
After you configure JetBrains, restart the IDE and select Poolside from the agent or assistant picker.

Set up other editors

For editors without automated setup, point the editor’s ACP configuration at pool acp:
{
  "command": "pool",
  "args": ["acp"]
}
To require a configured sandbox for the ACP server, pass --sandbox required:
{
  "command": "pool",
  "args": ["acp", "--sandbox", "required"]
}
Use --sandbox disabled only when you want the ACP server to run without a configured sandbox. Thought level is an ACP session config option, not a pool acp command-line flag. When your editor exposes ACP session config options, configure thought level from the editor’s agent or session settings.
Use thought level control only with models behind OpenRouter or another provider that accepts the OpenRouter-style reasoning field. If the underlying model connects directly to the OpenAI Chat Completions API at https://api.openai.com/v1/chat/completions, requests that include the reasoning field fail because OpenAI rejects the field.For Claude 4.6 models through OpenRouter, effort settings other than none are ignored. OpenRouter uses adaptive thinking automatically for those requests.
If an MCP server expects KEY, make sure your editor starts pool acp with KEY set.

Set up Neovim with CodeCompanion

If you use Neovim with the codecompanion.nvim plugin, configure Poolside as an ACP-backed adapter:
{
    "olimorris/codecompanion.nvim",
    dependencies = {
        "nvim-lua/plenary.nvim",
        "nvim-treesitter/nvim-treesitter",
    },
    opts = {
        strategies = {
            chat = { adapter = "poolside" },
            inline = { adapter = "poolside" },
        },
        adapters = {
            poolside = function()
                return {
                    name = "poolside",
                    formatted_name = "Poolside",
                    type = "acp",
                    commands = {
                        default = { "pool", "acp" },
                    },
                }
            end,
        },
    },
}

Modes

ModeIDWhat it does
Always askdefaultPrompts for approval on first use of each tool
Accept editsaccept-editsAuto-approves workspace file reads and writes, then prompts for everything else
Allow allalways-allowApproves tool actions automatically
PlanplanPlans changes without modifying your codebase
Mode switching depends on your editor client. If the editor does not expose ACP session modes, you may not be able to change modes from the UI.

Slash commands

pool acp handles these slash commands when your editor passes them to the server. Compatible clients may show commands that pool acp makes available in a command picker or autocomplete menu. Poolside also exposes available skills as slash commands to compatible ACP clients. The available skill commands depend on the skills configured for the agent and workspace.
CommandWhat it does
/planSwitch to plan mode
/clearClear conversation history and free up context
/compactCompact conversation context. Add guidance after the command to tell the agent what to preserve, such as /compact preserve tool call errors.
/shareGet the trajectory viewer URL for the current session when trajectory sharing is available
/mcpShow MCP servers, connection status, and tools for the current session
/sandboxShow local sandbox configuration
/sandbox-apply-to-hostReview pending sandbox filesystem changes and apply them to the host workspace when available
/usageShow token usage for the current session
/skillsRefresh and list available skills

Feature parity

The core agent capabilities are close to interactive mode, but exact support depends on the editor client:
  • Mode selection: Poolside ACP exposes session modes, including accept-edits and plan. Your editor must expose those controls for you to switch modes in the UI.
  • Model and thought level selection: Poolside ACP exposes model and thought level configuration as session config options. In standalone mode, model selection is limited to the default standalone configuration. When connected to a Poolside deployment, editors can expose deployment-specific agent or model choices if they support ACP session config options.
  • Rewind: Poolside ACP supports session rewind, but your editor has to expose that capability.
  • Session history: Poolside ACP supports persisted session history through ACP session listing and loading, but some editors do not expose history browsing in the UI.