This guide details a workflow for accessing a single instance of the Hermes AI agent from multiple devices, ensuring a unified session history, memory, and file system. The setup leverages Tailscale for secure, encrypted connections between devices, allowing a more powerful machine to act as the central processing unit for an AI agent accessible from less powerful or portable devices.

Benefits of a Unified Agent System

Utilizing a single Hermes agent across multiple devices offers several advantages over running separate instances:

• Centralized Session History: All interactions, regardless of the access device (laptop, desktop, mobile messaging apps like Telegram, Signal, or Discord), are logged in one location. This prevents fragmented conversations and maintains a continuous context.
• Leveraging Powerful Hardware: A more capable machine, such as a desktop with higher RAM (e.g., 32 GB), can run larger, more powerful local AI models. This processing power can then be accessed remotely from a less powerful device, such as a laptop with 24 GB of RAM, effectively using the laptop as a "window" into the desktop's capabilities.
• Organized File System: Project files can be consolidated on a central device, such as the desktop, and accessed as needed from any connected device, eliminating the need for complex file syncing systems across multiple machines.
• Continuous Operation: A desktop machine, typically always powered on, can host the agent, allowing it to run 24/7. Users can then access the agent from their laptop or other devices even when not actively working at the desktop, ensuring background tasks continue uninterrupted.
• End-to-End Encryption: By using a VPN solution like Tailscale, the connection between devices is end-to-end encrypted. This ensures that data does not need to pass through cloud servers, maintaining local and private operation.

Workflow Overview

The process involves setting up Tailscale on both the primary (server) and secondary (client) devices, configuring the Hermes agent on the server with dashboard credentials for secure authentication, and then connecting the client device to this remote dashboard.

Step 1: Installing and Configuring Tailscale

Tailscale creates a secure, private network (a "tailnet") between your devices, acting as a personal VPN.

1. Download Tailscale: Download the Tailscale application from tailscale.com. The website version is recommended over the App Store version for macOS due to potential compatibility issues.
2. Create an Account: Sign up for a Tailscale account using GitHub, Apple, or an email address.
3. Authorize Devices:
   • Upon first launch, authorize your first device. This adds it to your tailnet.
   • On macOS, you may need to grant network permissions and authorize the VPN.
   • Repeat this process on your second computer (e.g., your laptop).
4. Verify Tailnet: Access the Tailscale admin panel online. You should see both your server (e.g., Mac Studio) and client (e.g., MacBook Pro) devices listed. Each device will have a unique IP address within the tailnet.

Step 2: Setting Up Hermes Dashboard Credentials on the Server

To securely access the Hermes dashboard from another device, authentication must be enabled.

1. Modify Environment File: Edit the Hermes environment file by pasting a specific string. This string configures basic authentication for the Hermes dashboard, setting a username, password, and a randomly generated secret. The username and password can be customized.
2. Start the Hermes Dashboard: Open a terminal on the server device and run the command:

   hermes dashboard --host 0.0.0.0
   

   This command builds the web UI and makes it available on the local network. The terminal will display the HTTP URL, typically on port 9119.

The Hermes dashboard allows for profile switching, enabling the use of different configurations, models, and settings for various tasks. For instance, one profile might be configured to use a local model like Gemma 4 via Llama, while another might use GPT 5.5.

Step 3: Connecting the Client Device to the Hermes Agent

There are two primary methods to connect your client device to the Hermes agent running on the server:

Method 1: Using the Web Dashboard (Recommended for Flexibility)

This method is generally simpler and offers more flexibility, especially for using non-default Hermes profiles.

1. Open Browser: On your client device (e.g., laptop), open a web browser.
2. Navigate to Server's Tailscale Address: Enter the server's Tailscale IP address followed by the port number (e.g., http://<server_tailscale_ip>:9119).
3. Sign In: You will be prompted to sign in using the username and password configured in Step 2.
4. Access Hermes: Once authenticated, the browser will display the Hermes dashboard, providing access to the agent running on the server.
5. Profile Selection: The web dashboard allows you to select different Hermes profiles (e.g., "studio") to utilize specific configurations, sessions, memories, tools, skills, and model settings.

Method 2: Using the Native Hermes Desktop App (Remote Gateway)

This method uses the desktop application on the client device to connect to the remote Hermes backend.

Important Limitation: Currently, the remote gateway flow for the desktop app requires using the client device's default Hermes profile. Attempting to use a non-default profile may lead to connection issues after restarting the app.

1. Open Hermes Desktop App on Client: Launch the Hermes desktop application on your client device.
2. Access Settings: Press Command + , (or Control + ,) to open settings.
3. Navigate to Gateway Tab: Select the "Gateway" tab.
4. Toggle to Remote Gateway: Change the gateway connection from "Connected Locally" to "Remote Gateway."
5. Enter Server's Tailscale IP and Port:
   • Obtain the server's Tailscale IP address (e.g., from the Tailscale admin panel or by right-clicking the server device in the Tailscale app and copying its "MagicDNS hostname").
   • Construct the URL: http://<server_tailscale_ip>:9119.
6. Sign In and Reconnect: Click "Sign In" using the credentials set up in Step 2. Then, click "Save and Reconnect."
7. Test Connection: The Hermes desktop app on the client will restart and connect to the remote gateway. You can then interact with the agent. For example, asking "Hi, what device is this?" will result in the query being processed by the Hermes agent on the server (e.g., Mac Studio) and the answer returned to the client (e.g., MacBook Pro). The session history will be updated on the server.

Step 4: Sharing Files Across Devices

To ensure file access consistency, especially when operating within Docker containers, files can be shared across the Tailscale network.

1. Enable File Sharing on Server (macOS Example):
   • Go to System Settings > Sharing.
   • Enable "Content and Media" > "File Sharing."
   • Add the specific folder you want to share (e.g., "Hermes workspace") by clicking the "+" button. This makes the folder accessible to other devices on your network.
2. Mount Shared Folder on Client:
   • On the client device, open Finder.
   • Go to Go > Connect to Server.
   • Enter the server's Tailscale address in the format smb://<server_magicdns_hostname>.
   • Click "Connect."
   • When prompted, select the shared folder you enabled.
   • The shared folder will appear on your client device, allowing you to read and write files that are accessible to the Hermes agent on the server. This is crucial for maintaining a consistent workspace, particularly for AI operations within Docker.

Considerations for Memory and Persistence

• Active Connection Required: The unified memory and session history are maintained only while the client device is connected to the remote server backend via Tailscale.
• Offline Operation: If the server backend stops running or the client disconnects, the client's Hermes desktop app may offer to run locally. This creates a separate instance with its own session history and memory, which will not automatically sync with the server's data unless a separate memory sync strategy is implemented.
• Memory Providers: For more robust long-term memory systems, consider integrating external memory providers like Hindsight, Honcho, or Nemasean. These can write to separate database files. By running the backend on the server and connecting via a remote gateway from the client, all memories are centralized on the server's agent system.
• LLM Wiki Integration: Tools like Obsidian can be used to build an LLM Wiki, creating a long-term memory system that Hermes can write into and pass to different agents. This approach centralizes long-term memory and can be layered with other memory providers.

This setup provides a flexible and secure way to access a single, powerful AI agent from multiple devices, ensuring a consistent and continuous user experience.