HopToDesk and MCP: The First Remote Desktop App with AI Agent Support on Windows, Mac, and Linux
Remote desktop software has looked more or less the same for twenty years. You connect to a machine, you see the screen, you move the mouse, you type on the keyboard. The tools got faster and the encryption got stronger, but the fundamental interaction never changed. You are always the one doing the work.
That changes now. HopToDesk 1.45.10 now ships with a built-in MCP server that lets AI agents see, control, and manage remote machines programmatically. And it works on all three desktop operating systems: Windows, macOS, and Linux. No other remote desktop application offers MCP support across all three platforms.
This is not a plugin. It is not a third-party integration. The MCP server is built directly into HopToDesk and starts automatically when the application runs.
What Is MCP and Why Does It Matter for Remote Desktop
MCP, the Model Context Protocol, is an open standard introduced by Anthropic in late 2024 and now stewarded by the Linux Foundation alongside Google, OpenAI, Microsoft, and others. It defines a universal way for AI agents to discover and use tools provided by external software. Think of it as a USB port for AI: any agent that speaks MCP can plug into any application that runs an MCP server and immediately know what it can do.
For remote desktop software, this is a fundamental shift. Instead of a human manually clicking through menus, running diagnostics, and typing commands, an AI agent can do all of that directly. It can take a screenshot of a remote machine, analyze what is on the screen, click buttons, type text, transfer files, run system commands, and report back, all through a structured protocol that eliminates the ambiguity of natural language instructions to a human intermediary.
The practical impact is enormous. An IT support team can tell an AI agent to check the disk usage on a remote machine, restart a service, and send a chat message to the user explaining what happened, and the agent executes each step by calling well-defined MCP tools rather than trying to simulate human interaction through screen scraping or keyboard macros.
What HopToDesk's MCP Server Can Do
HopToDesk exposes 26 MCP tools organized into logical categories. Each tool is a structured operation with defined inputs and outputs, giving AI agents precise control without guesswork.
Screen and Input
The foundation of any remote desktop interaction is seeing the screen and providing input. HopToDesk's MCP server gives AI agents the same capabilities:
screenshot: Capture the remote display as a PNG image. The agent can crop to a specific region by specifying coordinates and dimensions, which is useful for monitoring a particular application window or dashboard widget without processing the entire screen.
get_window_list: List all visible windows with their titles, positions, and sizes. An agent can use this to find a specific application, determine if it is running, or decide where to click.
mouse_click: Move the mouse to specific coordinates and click. Supports left, right, and middle buttons, as well as single and double clicks.
mouse_move: Move the mouse without clicking. Useful for hovering over elements to trigger tooltips or menus.
type_text: Type text via keyboard input, including unicode characters.
key_press: Press a key or key combination. Supports modifier keys like ctrl, alt, shift, and meta, enabling the agent to use keyboard shortcuts such as ctrl+a to select all or alt+F4 to close a window.
These tools mean an AI agent can interact with any application on the remote machine exactly the way a human would, but faster and without mistakes caused by misreading what is on the screen.
Connection Management
An AI agent can manage multiple remote connections simultaneously:
connect_to_peer: Initiate a connection to a remote device by its HopToDesk ID. The agent can start a remote desktop session, a file transfer, or set up port forwarding. It can even supply a password to connect without manual intervention.
disconnect_peer: Cleanly close a remote connection.
list_active_connections: See all outgoing connections with their type and status.
list_incoming_connections: See who is connected to the local machine, including their authorization status and permissions.
This lets an agent orchestrate multi-machine workflows. It can connect to a server, check its status, transfer a configuration file from another machine, and disconnect when finished — all without human involvement.
Device Information
get_device_info: Retrieve the device's HopToDesk ID, version, platform, hostname, and signal server connection status.
list_peers: Browse known peers filtered by category: all, recent, favorites, or LAN-discovered devices.
Connection Control
Once connected to a remote machine, the agent has deep visibility into the session state:
get_ui_state: Returns rich structured data about the active connection, including toolbar buttons, connection quality metrics (speed, FPS, latency, codec), display information, permission states, any visible dialogs or popups, video dimensions, and view settings.
wait_for_event: Block until a specific event occurs, such as the connection becoming ready, a dialog appearing, or quality stabilizing. This lets agents write reliable automation sequences that wait for the right moment rather than using fragile timing delays.
dismiss_dialog: Dismiss modal dialogs that appear during a session.
click_toolbar_button: Interact with the HopToDesk toolbar programmatically. The agent can toggle fullscreen mode, open the chat panel, initiate a file transfer, start recording, or enable privacy mode. Submenus are accessible too, so the agent can send ctrl+alt+del, switch display modes, or change keyboard mapping.
send_chat_message: Send a text message to the remote user through HopToDesk's built-in chat.
Clipboard and Files
get_clipboard: Read the local clipboard text.
set_clipboard: Set the local clipboard to specified text.
list_local_files: Browse directory contents on the device, with an option to include hidden files.
read_local_file: Read a file's content, returned as text for text files or base64 for binary files, up to 1 MB.
Remote Printing
set_remote_printer: Configure which printer receives remote print jobs. Can auto-select when only one printer is available.
test_print: Send a test page to verify the remote print pipeline is working.
Permission Management
- switch_permission: Toggle incoming connection permissions for keyboard, clipboard, audio, file transfer, restart, and recording access. An agent can tighten or loosen permissions as part of an automated security workflow.
System Operations
For devices enrolled in HopToDesk Dashboard Pro, two powerful tools become available:
exec_operation: Execute predefined system operations including get_system_info, disk_usage, list_processes, network_info, get_service_logs, ping_test, installed_software, restart_hoptodesk, kill_process, flush_dns, reboot_device, clear_temp_files, and run_update_check.
run_command: Execute an arbitrary shell command on the remote machine. Uses cmd.exe on Windows and /bin/sh on macOS and Linux. Commands have a configurable timeout up to 120 seconds, and output is captured up to 64 KB.
These system operations turn HopToDesk into a full remote management platform that an AI agent can operate independently, running diagnostics, applying fixes, and verifying results.
Three Ways to Connect
HopToDesk's MCP server supports three transport modes, so it fits into whatever architecture your AI workflow requires.
WebSocket is the default on Windows and macOS. When HopToDesk runs, it automatically starts a WebSocket server on ws://127.0.0.1:9333. The port is configurable. This is the best option when an AI agent needs to connect to a running HopToDesk instance. On Linux, the WebSocket transport is not available — use stdio or TCP mode instead.
Stdio mode is started by launching HopToDesk with the --mcp flag. In this mode, HopToDesk reads JSON-RPC messages from stdin and writes responses to stdout. This is the standard pattern for AI agent integrations and works directly with Claude Desktop, Claude Code, and other MCP-compatible tools. You add HopToDesk to your agent's MCP server configuration, and the agent launches it as a child process with no additional setup.
TCP mode is started with the --mcp-port flag and listens on a specified port. This is useful for integrations that need a persistent network connection but cannot use WebSocket.
All three modes use the JSON-RPC 2.0 protocol and conform to MCP protocol version 2024-11-05.
Security by Design
Remote desktop software that accepts commands from AI agents needs a robust security model. HopToDesk's MCP implementation addresses this from multiple angles.
Localhost only. All three transport modes bind exclusively to 127.0.0.1. The MCP server is never accessible from the network. An AI agent must be running on the same machine as HopToDesk.
Token authentication. WebSocket and TCP connections require a valid authentication token as the first message. The token is randomly generated and written to a discovery file called mcp.json in the HopToDesk configuration directory. On macOS and Linux, this file has owner-only permissions (0600), preventing other users on the system from reading it. The file is automatically deleted when HopToDesk exits.
Stdio mode, by definition, does not require a token because the AI agent is the process that launched HopToDesk — the trust boundary is the operating system's process model.
Confirmation annotations. Destructive operations like run_command, exec_operation, and disconnect_peer are annotated in the MCP tool definitions as requiring user confirmation. AI agents that follow MCP conventions will prompt the user before executing these operations rather than running them silently.
Setting It Up
Getting HopToDesk's MCP server working with an AI agent takes about thirty seconds.
For Claude Desktop, add HopToDesk to your MCP server configuration:
{ "mcpServers": { "hoptodesk": { "command": "/path/to/hoptodesk", "args": ["--mcp"] } } }
Replace /path/to/hoptodesk with the actual path to the HopToDesk executable on your system. On Windows that might be C:\Program Files\HopToDesk\hoptodesk.exe, on macOS /Applications/HopToDesk.app/Contents/MacOS/hoptodesk, on Linux /usr/bin/hoptodesk or wherever you installed it.
That is the entire setup. Claude Desktop will launch HopToDesk in stdio mode, discover the 26 available tools, and you can start asking it to manage remote machines.
For agents that prefer the WebSocket transport, start HopToDesk normally and have your agent read the mcp.json discovery file from HopToDesk's configuration directory. The file contains the URL, port, and authentication token — everything the agent needs to connect.
What This Looks Like in Practice
Here are some workflows that become possible when an AI agent can control HopToDesk:
Automated IT diagnostics. "Check the disk space, memory usage, and running services on our warehouse server, then summarize anything that looks unusual." The agent connects to the remote machine, runs exec_operation with the appropriate system commands, analyzes the output, and presents a summary. What used to require a technician to connect, open a terminal, run commands, and interpret output now happens in a single request.
Guided troubleshooting. A support agent takes a screenshot of the remote machine, identifies error dialogs, reads log files, and walks through a fix — clicking buttons, editing configuration files, and restarting services. It sends a chat message to the remote user explaining what it did.
Multi-machine health checks. An agent iterates through a list of peers, connects to each one, runs a standardized set of diagnostics, disconnects, and produces a consolidated report. A managed services provider with dozens of client machines can get a morning health report without a human touching any of them.
Automated software deployment. Connect to a remote machine, transfer an installer file, run it via run_command, verify the installation by checking installed_software, and disconnect. Repeat across a fleet of machines.
Intelligent monitoring. An agent periodically connects to critical machines, takes screenshots of specific application windows, and uses vision capabilities to detect anomalies — a dashboard chart spiking, an error count increasing, a service showing as stopped. It can respond to what it sees, not just what structured monitoring data tells it.
Why All Three Platforms Matter
MCP support that only works on one or two operating systems creates gaps in exactly the environments where AI-powered remote management is most valuable. Enterprise IT teams do not manage homogeneous fleets. They manage Windows workstations, macOS laptops for design teams, and Linux servers running production infrastructure. A managed services provider supports whatever their clients run.
HopToDesk's MCP server is built into the same codebase that runs on all three platforms. The same 26 tools, the same transport modes, the same security model, the same JSON-RPC protocol, regardless of whether the machine runs Windows, macOS, or Linux. An AI agent does not need platform-specific logic or different integration paths. It connects to HopToDesk and gets the same capabilities everywhere.
This is what makes HopToDesk the first remote desktop application to deliver full MCP support across all three desktop operating systems. The combination of cross-platform coverage and a comprehensive 26-tool MCP interface means AI agents can manage any desktop machine in an organization through a single, consistent integration.
The Bigger Picture
MCP is doing for AI agents what REST APIs did for web applications: creating a common language that lets different systems work together without custom integration code. Remote desktop software sits at a critical junction in that ecosystem because it is the tool that gives AI agents physical access to machines, not just data, but the ability to see screens, click buttons, type text, and run commands.
HopToDesk's decision to build MCP support directly into the application, rather than offering it as an add-on or requiring a separate bridge service, reflects where remote desktop is heading. The next generation of IT management will not be humans staring at remote screens. It will be AI agents that can see, understand, and act on what they find — with a human reviewing the results and authorizing the important decisions.
That future requires remote desktop software that speaks the language AI agents understand. HopToDesk does, on every platform that matters.
Ready to try the new MCP support? Download HopToDesk free at hoptodesk.com.
