Running Hermes in VS Code and Zed via the ACP Adapter

Agent Communication Protocol (ACP) is an open protocol that lets editors talk to agent runtimes without caring which runtime is on the other end. VS Code, Zed, and JetBrains all ship ACP-compatible clients. Hermes Agent ships hermes-acp, an entry point that speaks ACP on one side and talks to the Hermes daemon on the other.

The result: you get a Hermes agent panel inside your editor that keeps its memory, tools, and gateway connections across sessions. Closing VS Code does not kill the agent. Opening Zed on the same machine gives you the same agent. This is different from the Claude Code VS Code extension, which is tied to a per-workspace CLI session.

This walkthrough covers installing Hermes, enabling ACP, wiring up each editor, and sending a first message.

Key Takeaways

• hermes-acp is an ACP server bundled with Hermes that proxies to the running hermes-agent daemon.
• VS Code, Zed, and JetBrains all support ACP; setup differs per editor but the Hermes side is identical.
• The editor becomes a thin UI over a persistent agent; memory and skills persist across editor restarts.
• ACP integration coexists with messaging gateways and cron; the same daemon serves all of them.
• Contrast with the Claude Code VS Code extension: Hermes is daemon-backed, Claude Code is CLI-backed.
• One Hermes install can serve multiple editors on the same machine simultaneously.

Step 1: Install Hermes and Start the Daemon

Install from the upstream script on a machine where you do your editing (local or a dev VPS you can reach):

curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash

This gives you hermes and hermes-acp on your PATH. Configure the Claude provider (Hermes will read the Claude Code credential store if one exists, or you can pass ANTHROPIC_API_KEY):

hermes config set provider anthropic
hermes config set model claude-sonnet-4-6

Start the daemon:

hermes daemon start

Verify it is up:

hermes status

Step 2: Enable ACP in Hermes

ACP is served by a separate entry point, hermes-acp, which the editor will launch. You do not start hermes-acp manually — the editor does. But you should verify the binary works and points at your running daemon.

hermes-acp --check

If the daemon is up and credentials are configured, this returns a short OK message and exits.

Step 3: Zed (Native ACP)

Zed has first-class ACP support. In your Zed settings (~/.config/zed/settings.json on Linux/macOS):

{
  "agent": {
    "default_profile": "hermes",
    "profiles": {
      "hermes": {
        "name": "Hermes",
        "command": "hermes-acp",
        "args": []
      }
    }
  }
}

Restart Zed, open the agent panel (cmd+? on macOS), and select Hermes from the profile dropdown. Send a message. It flows: Zed UI → ACP → hermes-acp → Hermes daemon → Claude.

Because the daemon is persistent, anything Hermes remembers from your Telegram gateway, cron runs, or CLI sessions is visible here. Ask "what did I ask you to remind me about yesterday?" and it will answer from the FTS5-indexed memory store.

Step 4: VS Code

VS Code needs an ACP client extension. Install the ACP client from the marketplace (search for "Agent Communication Protocol"), then configure Hermes as a provider in your settings.json:

{
  "acp.providers": {
    "hermes": {
      "command": "hermes-acp",
      "args": [],
      "displayName": "Hermes Agent"
    }
  },
  "acp.defaultProvider": "hermes"
}

Open the ACP panel (Command Palette → "ACP: Open Panel") and you get a chat UI wired to the same Hermes daemon.

Compare this to the Claude Code VS Code extension: that extension spawns a per-workspace claude CLI process. Close the workspace, you lose the session. The ACP setup with Hermes holds state in the daemon, not the workspace, so the agent's memory outlives any single project.

Step 5: JetBrains

JetBrains IDEs (IntelliJ, PyCharm, WebStorm, etc.) support ACP via a plugin. Install the "Agent Communication Protocol" plugin from the JetBrains Marketplace, then configure Hermes in Settings → Tools → ACP:

• Provider name: hermes
• Command: hermes-acp
• Arguments: leave empty

Open the ACP tool window. Same agent, same memory, same tools.

Step 6: First Message and What Happens Underneath

Send this in any of the three editors:

"List the tools you have access to and tell me which of them need MCP servers to be running."

You should see Hermes enumerate its 47 built-in tools (filesystem, shell, git, memory search, etc.) plus any MCP servers configured in ~/.hermes/config.yaml. Because the daemon is persistent, the MCP servers are already warm — no cold start, unlike the per-invocation Claude Code lifecycle.

Under the hood:

1. Editor sends ACP request over stdio to hermes-acp.
2. hermes-acp forwards to the running daemon.
3. Daemon runs the agent loop (planning, tool calls, memory reads/writes) against Claude.
4. Streaming response flows back: daemon → hermes-acp → editor UI.

Close the editor. The daemon keeps running. Open a different editor on the same machine, connect via ACP, continue the conversation. Or let a Telegram message hit the daemon while you are editing — the memory is shared.

Multi-Editor Caveats

One machine, one Hermes daemon, multiple editors — works. Multiple users on the same machine want isolated agents — run separate daemons on different sockets and point each user's hermes-acp at their own daemon via HERMES_SOCKET.

Remote development (VS Code Remote, JetBrains Gateway) also works: install Hermes on the remote host, run the daemon there, and the editor's ACP client connects over the remote's transport. This is genuinely useful for the $5/mo VPS setup described in installing Hermes Agent on a 5 dollar VPS.

Contrast with the Claude Code VS Code Extension

Both are good; they solve different problems.

If you primarily want in-IDE Claude Code, use the Claude Code extension. If you want one agent that you talk to from any editor, messaging app, or cron trigger, use Hermes via ACP.

For more context on Hermes's relationship to Claude Code, see Hermes vs Claude Code: when to use which. For the underlying MCP differences that carry through ACP, see MCP in Hermes vs MCP in Claude Code.

Sources

• GitHub: NousResearch/hermes-agent
• Hermes docs: hermes-agent.nousresearch.com/docs/
• Agent Communication Protocol spec and client references (Zed, VS Code, JetBrains)
• Related: Hermes vs Claude Code: when to use which
• Related: Installing Hermes Agent on a 5 dollar VPS
• Related: MCP in Hermes vs MCP in Claude Code