Connect your coding agent

Connect your agent.

Install Hronaut on the computer running your agent, then follow its connection guide. Need the app? Download Hronaut →

Copy tested setup

Choose your coding agent

Use Hronaut Home for your current port and authentication settings. Running in WSL, Docker, a VM, or Remote SSH? Check the connection boundary →

Show all connection commands and configurations

A new Hronaut profile requires its MCP token, and these examples send it. Hronaut Home shows the same setup with your profile's token file filled in, so copy it from there instead of pasting a token into chat or source control. A profile whose Require MCP authentication is off connects without the token; each client's guide shows that setup too.

Codex

User-level configuration

Adds the server to ~/.codex/config.toml, with the token in an environment variable rather than the file.

export HRONAUT_MCP_TOKEN="$(cat '/path/from-hronaut-home')"
codex mcp add hronaut --url http://127.0.0.1:47812/mcp --bearer-token-env-var HRONAUT_MCP_TOKEN

Codex CLI and the ChatGPT desktop app can use the plugin instead. Open the focused Codex browser MCP walkthrough →

Claude Code

User-level HTTP transport

The user scope makes Hronaut available across projects. Set up Claude Code on Hronaut Home adds the same server for you.

export HRONAUT_MCP_TOKEN="$(cat '/path/from-hronaut-home')"
claude mcp add --transport http --scope user --header "Authorization: Bearer $HRONAUT_MCP_TOKEN" hronaut http://127.0.0.1:47812/mcp

Or use the plugin. Open the focused Claude Code browser MCP walkthrough →

Gemini CLI

~/.gemini/settings.json

The user settings make Hronaut available across projects.

{
  "mcpServers": {
    "hronaut": {
      "httpUrl": "http://127.0.0.1:47812/mcp",
      "headers": {
        "Authorization": "Bearer <owner-token>"
      }
    }
  }
}

Start Hronaut, then run gemini mcp list to verify the connection. Open the focused Gemini CLI browser MCP walkthrough →

VS Code / GitHub Copilot

.vscode/mcp.json

Save in the workspace, or use MCP: Open User Configuration for global access.

{
  "servers": {
    "hronaut": {
      "type": "http",
      "url": "http://127.0.0.1:47812/mcp",
      "headers": {
        "Authorization": "Bearer <owner-token>"
      }
    }
  }
}

Keep the token in user configuration, never in a committed .vscode/mcp.json.

Open the focused VS Code and GitHub Copilot browser MCP walkthrough →

OpenCode

~/.config/opencode/opencode.json

Use the global file to make Hronaut available across projects, or put the same configuration in opencode.json at one project root. Add Hronaut as a remote Streamable HTTP server and disable OAuth discovery because Hronaut uses its own bearer header.

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "hronaut": {
      "type": "remote",
      "url": "http://127.0.0.1:47812/mcp",
      "enabled": true,
      "oauth": false,
      "headers": {
        "Authorization": "Bearer {file:/path/from-hronaut-home}"
      }
    }
  }
}

This example follows the official stable OpenCode MCP guide ↗. OpenCode V2: place the same hronaut object under mcp.servers and omit enabled; V2 connects unless disabled is true. See the official V2 MCP guide ↗.

Start Hronaut, then run opencode mcp list to verify the connection. Copy the OpenCode configuration from Hronaut Home, which fills in the path: OpenCode's {file:...} substitution reads the owner-only token file without storing the token in this JSON. Run opencode mcp debug hronaut for connection or authentication diagnostics.

Open the focused OpenCode browser MCP walkthrough →

Kilo Code

~/.config/kilo/kilo.jsonc

Add Hronaut under Kilo Code's top-level mcp key. This global file is shared by local Kilo Code IDE, CLI, and JetBrains clients.

{
  "$schema": "https://app.kilo.ai/config.json",
  "mcp": {
    "hronaut": {
      "type": "remote",
      "url": "http://127.0.0.1:47812/mcp",
      "enabled": true,
      "oauth": false,
      "headers": {
        "Authorization": "Bearer {file:/path/from-hronaut-home}"
      }
    }
  }
}

Start Hronaut, then run kilo mcp list. This loopback setup works only when Kilo Code and Hronaut run on the same machine; current Kilo Cloud Agent MCP support is documented as coming. Official Kilo Code MCP guide ↗

Open the focused Kilo Code browser MCP walkthrough →

JetBrains Junie

~/.junie/mcp/mcp.json

Junie CLI and Junie in JetBrains IDEs use the same MCP JSON configuration. Use the user-level file to make Hronaut available across projects.

{
  "mcpServers": {
    "hronaut": {
      "url": "http://127.0.0.1:47812/mcp",
      "headers": {
        "Authorization": "Bearer <owner-token>"
      }
    }
  }
}

Start Hronaut, then run /mcp in Junie and confirm hronaut is Active. This loopback setup works only when Junie and Hronaut run on the same computer. Official Junie MCP guide ↗

Open the focused JetBrains Junie browser MCP walkthrough →

Devin Local

~/.config/devin/mcp_config.json

Devin Local is the default agent for new Devin Desktop tabs. Add Hronaut at user scope so the same local browser is available across projects.

{
  "mcpServers": {
    "hronaut": {
      "url": "http://127.0.0.1:47812/mcp",
      "transport": "http",
      "headers": {
        "Authorization": "Bearer ${file:/path/from-hronaut-home}"
      }
    }
  }
}

Start Hronaut, then run devin mcp list and devin mcp get hronaut. Cloud Devin sessions cannot reach a loopback service on your computer. Existing legacy Cascade users need its Windsurf-era file and serverUrl field. Official Devin MCP guide ↗

Open the focused Devin Local browser MCP walkthrough →

Zed

User-level context_servers

Add Hronaut as a custom remote server for Zed Agent and ACP-forwarded external agents. With the Authorization field present, Zed does not start an OAuth flow, which Hronaut does not implement.

{
  "context_servers": {
    "hronaut": {
      "url": "http://127.0.0.1:47812/mcp",
      "headers": {
        "Authorization": "Bearer <owner-token>"
      }
    }
  }
}

Put the actual bearer token in private local user settings; Zed does not document secret interpolation for this field. Official Zed MCP guide ↗

Open the focused Zed browser MCP walkthrough →

Grok Build

~/.grok/config.toml

Add Hronaut to xAI's local Grok Build CLI as a user-scoped native HTTP MCP server.

grok mcp add --transport http hronaut http://127.0.0.1:47812/mcp --header 'Authorization: Bearer ${HRONAUT_MCP_TOKEN}'

Start Hronaut, then run grok mcp doctor hronaut. This loopback setup is for Grok Build running on the same computer; hosted grok.com and @grok cannot reach it. Official Grok Build MCP guide ↗

Open the focused Grok Build browser MCP walkthrough →

Qwen Code

~/.qwen/settings.json

Add Hronaut to the local Qwen Code CLI as a user-scoped native Streamable HTTP MCP server.

{
  "mcpServers": {
    "hronaut": {
      "httpUrl": "http://127.0.0.1:47812/mcp",
      "headers": {
        "Authorization": "Bearer ${HRONAUT_MCP_TOKEN}"
      },
      "trust": false
    }
  }
}

Start Hronaut, run qwen mcp list, then use /mcp inside Qwen Code. This loopback setup is for a local Qwen Code process; Qwen Chat and remote sessions cannot reach it. Official Qwen Code MCP guide ↗

Open the focused Qwen Code browser MCP walkthrough →

Goose

~/.config/goose/config.yaml

Add Hronaut to local Goose Desktop and CLI sessions as a persistent Streamable HTTP extension.

extensions:
  hronaut:
    type: streamable_http
    name: hronaut
    enabled: true
    uri: "http://127.0.0.1:47812/mcp"
    headers:
      Authorization: "Bearer ${HRONAUT_MCP_TOKEN}"
    env_keys:
      - HRONAUT_MCP_TOKEN
    envs: {}
    timeout: 300

Start Hronaut, then open Goose Extensions to confirm the server. The entry references HRONAUT_MCP_TOKEN through env_keys and Goose's secret store; never paste the owner token into config.yaml. Official Goose configuration reference ↗

Open the focused Goose browser MCP walkthrough →

Zoo Code

Global MCP configuration

Open Zoo Code → MCP Servers → Edit Global MCP, then add Hronaut as a Streamable HTTP server. Keep the approval list empty until you have reviewed the available browser tools.

{
  "mcpServers": {
    "hronaut": {
      "type": "streamable-http",
      "url": "http://127.0.0.1:47812/mcp",
      "headers": {
        "Authorization": "Bearer ${env:HRONAUT_MCP_TOKEN}"
      },
      "alwaysAllow": [],
      "disabled": false
    }
  }
}

Set HRONAUT_MCP_TOKEN in the environment that launches the editor, then confirm hronaut is connected in Zoo Code's MCP Servers view. Official Zoo Code MCP guide ↗

Open the focused Zoo Code browser MCP walkthrough →

Mistral Vibe

~/.vibe/config.toml

Vibe CLI and the local VS Code extension share MCP configuration. Use explicit static authentication so Vibe does not start an OAuth flow that Hronaut does not implement.

[[mcp_servers]]
name = "hronaut"
transport = "streamable-http"
url = "http://127.0.0.1:47812/mcp"

[mcp_servers.auth]
type = "static"
api_key_env = "HRONAUT_MCP_TOKEN"
api_key_header = "Authorization"
api_key_format = "Bearer {token}"

Vibe's environment-backed API-key fields read the token from HRONAUT_MCP_TOKEN. Vibe Code Web cannot reach a loopback service on your desktop. Official Vibe MCP guide ↗

Open the focused Mistral Vibe browser MCP walkthrough →

Warp

~/.warp/.mcp.json

Warp's local Agent supports URL-based Streamable HTTP servers. A user-level definition is available across repositories and auto-spawns without trusting a project-scoped server file.

{
  "mcpServers": {
    "hronaut": {
      "url": "http://127.0.0.1:47812/mcp",
      "headers": {
        "Authorization": "Bearer <owner-token>"
      }
    }
  }
}

Open Settings → Agents → MCP servers to inspect running state, tools, and View Logs. This loopback setup is for a local Warp Agent; a Warp-hosted cloud agent cannot reach a service on your desktop. Official Warp MCP guide ↗

Open the focused Warp browser MCP walkthrough →

Windsurf

~/.codeium/windsurf/mcp_config.json

Add Hronaut to Windsurf Cascade as a user-level Streamable HTTP server. The same entry remains available across local projects.

{
  "mcpServers": {
    "hronaut": {
      "serverUrl": "http://127.0.0.1:47812/mcp",
      "headers": {
        "Authorization": "Bearer ${file:/path/from-hronaut-home}"
      }
    }
  }
}

Open Cascade → MCPs, refresh the server list, and confirm that hronaut is connected. The entry reads the owner-only token with ${file:...} interpolation instead of publishing the secret in JSON. Official Windsurf MCP guide ↗

Open the focused Windsurf Cascade walkthrough →

Generic MCP client

Streamable HTTP

Use the standard transport and point the client directly at Hronaut.

{
  "name": "hronaut",
  "transport": "streamable-http",
  "url": "http://127.0.0.1:47812/mcp",
  "headers": {
    "Authorization": "Bearer <owner-token>"
  }
}

Shared configuration templates: Hronaut v3.14.33. Verified release source. Client-specific CLI shortcuts and newer client variants are identified in their focused guides.

Plugins

Or install a plugin.

Claude Code, Codex and VS Code can add Hronaut as a plugin. It reads Hronaut's MCP token on its own, so there is nothing to paste. Start Hronaut first. The plugins and the extension are open source under the MIT License.

Claude Code plugin

Run in Claude Code

/plugin marketplace add hronaut/hronaut-claude-plugin
/plugin install hronaut@hronaut

/mcp then shows Hronaut. Added it with claude mcp add before? Run claude mcp remove hronaut --scope user, or Claude Code keeps using that entry. Plugin source ↗

Codex plugin

Run in a terminal

codex plugin marketplace add hronaut/hronaut-codex-plugin
codex plugin add hronaut@hronaut

For Codex CLI and Codex in the ChatGPT desktop app. Start a new session; /mcp shows Hronaut. The Codex IDE extension does not load plugins: use the Codex guide. Plugin source ↗

VS Code extension

Install the Hronaut extension

code --install-extension hronaut.hronaut

Adds Hronaut to the editor's MCP servers, so agents such as GitHub Copilot can use it without an mcp.json entry. Editors that install extensions from Open VSX get the same extension there. Added Hronaut to mcp.json before? Remove that entry, so the agent does not get its tools twice. Extension source ↗

Installation and connection steps

Start here

Four steps to a durable browser session

  1. 1

    Install and launch Hronaut

    Download the package for Windows, macOS, or Linux. On Mac, use macOS 13 Ventura or newer and choose Apple Silicon or Intel for your processor. The Mac packages are signed and notarized by Apple. You can verify any package with the published hashes or artifact attestations.

  2. 2

    Open Hronaut Home

    Confirm that the MCP server is online and copy the setup for your client. New profiles default to port 47812.

  3. 3

    Add one client configuration

    Use the matching command or JSON below, then refresh or restart the coding agent so it loads the new MCP server.

  4. 4

    Verify the connection

    Hronaut Home shows active and recently seen clients. Ask the agent to create a named workspace before it opens pages.

Default endpoint

http://127.0.0.1:47812/mcp

Hronaut listens only on loopback and requires the profile's MCP token. Copy the client-specific snippet from Hronaut Home; it always reflects the active port and authentication settings.

10-day trial from your first agent tool call. It needs no card, and nothing is charged when it ends. Then $4/month or $24/year per named user. Bring your own coding agent and AI model.

Connection troubleshooting

Test the endpoint without an agent in the middle.

If your agent can’t connect, ask Hronaut for its tool list with the official MCP Inspector first. If that works, the problem is in the client’s configuration.

Security boundary

Keep authentication on.

A new profile requires the owner token for MCP, so other processes running as you cannot control the Hronaut browser profile. A profile from before Hronaut 3.5 keeps the setting it saved: if Require MCP authentication is off in Settings → MCP security, turn it on before you use sensitive signed-in sessions, and copy the regenerated client setup from Hronaut Home.

The token is stored in an owner-only file and is never displayed by Hronaut Home. Do not paste it into issues, screenshots, source control, or community posts.

First task

Prove the connection in an isolated workspace.

Once your client lists Hronaut under its connections, send it this first check.

Ask your agent

“Create a Hronaut workspace named first-check, open https://example.com inside it, and tell me the page title and workspace ID. Start with clean scratch storage.”

Expected result: a visible first-check workspace opens Example Domain, and the agent reports its stable workspace ID. That proves the client can create an isolated browser profile and navigate it without reusing another workspace’s site state.

  • Check a local change. Let your agent open your running app, try a flow, and report what it sees. Localhost workflow →
  • Sign in yourself. Handle the login, then let the agent continue in the same workspace. Safe login handoff →
  • Come back later. After reconnecting, the task resumes with its workspace ID and private resume key. Complete reference →

Optional workflow guide

Install the Hronaut Agent Skill.

For clients that support Agent Skills, this source-available skill teaches isolated workspaces, semantic browser actions, and private human handoff. It does not install Hronaut, configure MCP, or contain secrets. Complete the MCP setup above first.

Install from source

npx skills add hronaut/hronaut --skill hronaut