Agent Client Protocol (ACP)

no
Summary: Expose Deep Agents over the Agent Client Protocol (ACP) to integrate with code editors and IDEs.

Original Documentation

Documentation Index#

Fetch the complete documentation index at: https://docs.langchain.com/llms.txt Use this file to discover all available pages before exploring further.

Expose Deep Agents over the Agent Client Protocol (ACP) to integrate with code editors and IDEs.

Agent Client Protocol (ACP) standardizes communication between coding agents and code editors or IDEs. With the ACP protocol, you can make use of your custom deep agents with any ACP-compatible client, allowing your code editor to provide project context and receive rich updates.

ACP is designed for agent-editor integrations. If you want your agent to call tools hosted by external servers, see Model Context Protocol (MCP).

Quickstart#

Install the ACP integration package:

npm install deepagents-acp
yarn add deepagents-acp
pnpm add deepagents-acp

Then expose a Deep Agent over ACP.

This starts an ACP server in stdio mode (it reads requests from stdin and writes responses to stdout). In practice, you usually run this as a command launched by an ACP client (for example, your editor), which then communicates with the server over stdio.


await startServer({
  agents: {
    name: "coding-assistant",
    description: "AI coding assistant with filesystem access",
  },
  workspaceRoot: process.cwd(),
});

You can also use the CLI without writing any code:

npx deepagents-acp

The deepagents-acp package provides both a CLI and a programmatic API for exposing deep agents over ACP.

Clients#

Deep Agents works anywhere you can run an ACP agent server. Some notable ACP clients include:

Zed#

Register your deep agent with Zed by adding it to your Zed settings (~/.config/zed/settings.json on Linux, ~/Library/Application Support/Zed/settings.json on macOS):

Simple setup (no code required):

{
  "agent": {
    "profiles": {
      "deepagents": {
        "name": "DeepAgents",
        "command": "npx",
        "args": ["deepagents-acp"],
        "env": {
          "ANTHROPIC_API_KEY": "sk-ant-..."
        }
      }
    }
  }
}

With CLI options:

{
  "agent": {
    "profiles": {
      "deepagents": {
        "name": "DeepAgents",
        "command": "npx",
        "args": [
          "deepagents-acp",
          "--name", "my-assistant",
          "--skills", "./skills",
          "--debug"
        ],
        "env": {
          "ANTHROPIC_API_KEY": "sk-ant-..."
        }
      }
    }
  }
}

Custom server script:

For more control, create a TypeScript server script:

// server.ts

await startServer({
  agents: {
    name: "my-agent",
    description: "My custom coding agent",
    skills: ["./skills/"],
  },
});

Then point Zed at it:

{
  "agent": {
    "profiles": {
      "my-agent": {
        "name": "My Agent",
        "command": "npx",
        "args": ["tsx", "./server.ts"]
      }
    }
  }
}

Open Zed’s Agents panel and start a DeepAgents thread.

ACP Registry#

DeepAgents is available in the ACP Agent Registry for one-click installation in Zed and JetBrains IDEs. When an ACP client supports the registry, users can discover and install Deep Agents without any manual configuration.

CLI reference#

The CLI is the fastest way to start an ACP server. It requires no code — just run npx deepagents-acp and connect your editor.

npx deepagents-acp [options]
OptionShortDescription
--name <name>-nAgent name (default: "deepagents")
--description <desc>-dAgent description
--model <model>-mLLM model (default: "claude-sonnet-4-5-20250929")
--workspace <path>-wWorkspace root directory (default: cwd)
--skills <paths>-sComma-separated skill paths
--memory <paths>Comma-separated AGENTS.md paths
--debugEnable debug logging to stderr
--help-hShow help message
--version-vShow version

Environment variables#

VariableDescription
ANTHROPIC_API_KEYAPI key for Anthropic/Claude models (required)
OPENAI_API_KEYAPI key for OpenAI models
DEBUGSet to "true" to enable debug logging
WORKSPACE_ROOTAlternative to --workspace flag

Programmatic API#

startServer#

Convenience function to create and start a server in one call:


const server = await startServer({
  agents: {
    name: "coding-assistant",
    description: "AI coding assistant with filesystem access",
  },
  workspaceRoot: process.cwd(),
});

DeepAgentsServer#

For full control, use the DeepAgentsServer class directly:


const server = new DeepAgentsServer({
  agents: [
    {
      name: "code-agent",
      description: "Full-featured coding assistant",
      model: "claude-sonnet-4-5-20250929",
      skills: ["./skills/"],
      memory: ["./.deepagents/AGENTS.md"],
    },
    {
      name: "reviewer",
      description: "Code review specialist",
      systemPrompt: "You are a code review expert...",
    },
  ],
  serverName: "my-deepagents-acp",
  serverVersion: "1.0.0",
  workspaceRoot: process.cwd(),
  debug: true,
});

await server.start();

Server options#

OptionTypeDefaultDescription
agentsDeepAgentConfig | DeepAgentConfig[]requiredAgent configuration(s)
serverNamestring"deepagents-acp"Server name for ACP
serverVersionstring"0.0.1"Server version
workspaceRootstringprocess.cwd()Workspace root directory
debugbooleanfalseEnable debug logging

Agent configuration#

OptionTypeDescription
namestringUnique agent name (required)
descriptionstringAgent description
modelstringLLM model (default: "claude-sonnet-4-5-20250929")
toolsStructuredTool[]Custom LangChain tools
systemPromptstringCustom system prompt
middlewareAgentMiddleware[]Custom middleware
backendBackendProtocol | BackendFactoryFilesystem backend
skillsstring[]Skill source paths
memorystring[]Memory source paths (AGENTS.md)
interruptOnRecord<string, boolean | InterruptOnConfig>Tools requiring user approval (HITL)
commandsArray<{ name, description, input? }>Custom slash commands

Customization#

Multiple agents#

You can expose multiple agents from a single server. The ACP client selects which agent to use when creating a session:

const server = new DeepAgentsServer({
  agents: [
    { name: "code-agent", description: "General coding" },
    { name: "reviewer", description: "Code reviews" },
  ],
});

Some ACP clients (like Zed) don’t currently expose a UI for selecting between agents. In that case, consider running separate server instances with a single agent each.

Slash commands#

The server registers built-in slash commands with the IDE: /plan, /agent, /ask, /clear, and /status. You can also define custom commands per agent:

const server = new DeepAgentsServer({
  agents: {
    name: "my-agent",
    commands: [
      { name: "test", description: "Run the project's test suite" },
      { name: "lint", description: "Run linter and fix issues" },
      {
        name: "deploy",
        description: "Deploy to staging",
        input: { hint: "environment (staging or production)" },
      },
    ],
  },
});

Human-in-the-loop#

Use interruptOn to require user approval in the IDE before the agent runs sensitive tools:

const server = new DeepAgentsServer({
  agents: {
    name: "careful-agent",
    interruptOn: {
      execute: { allowedDecisions: ["approve", "edit", "reject"] },
      write_file: true,
    },
  },
});

When the agent calls a protected tool, the IDE prompts the user to allow or reject the operation, with options to remember the decision for the session.

Custom tools#




const searchTool = tool(
  async ({ query }) => {
    return `Results for: ${query}`;
  },
  {
    name: "search",
    description: "Search the codebase",
    schema: z.object({ query: z.string() }),
  },
);

const server = new DeepAgentsServer({
  agents: {
    name: "search-agent",
    tools: [searchTool],
  },
});

await server.start();

Custom backend#



const server = new DeepAgentsServer({
  agents: {
    name: "custom-agent",
    backend: new CompositeBackend({
      routes: [
        {
          prefix: "/workspace",
          backend: new FilesystemBackend({ rootDir: "./workspace" }),
        },
        { prefix: "/", backend: (config) => new StateBackend(config) },
      ],
    }),
  },
});

await server.start();

Skills and memory#


await startServer({
  agents: {
    name: "project-agent",
    description: "Agent with project-specific knowledge",
    skills: ["./skills/", "~/.deepagents/skills/"],
    memory: ["./.deepagents/AGENTS.md"],
  },
  workspaceRoot: process.cwd(),
});

See the upstream ACP docs for protocol details and editor support:


Edit this page on GitHub or file an issue.

Connect these docs to Claude, VSCode, and more via MCP for real-time answers.

Link last verified June 7, 2026. View original ↗
Source: LangChain Docs
Link last verified: 2026-04-05