Skip to main content
Glama

🚀 Quick start

  1. Connect your agent: Add the MCP service https://agenterm.net/mcp to an agent that supports Streamable HTTP. See configuration examples.

  2. Invite and authorize: Ask the agent to create an invitation and privately share its short link, such as https://agenterm.net/c/xef2k1. The recipient opens it on the computer that needs assistance, launches the CLI, and authorizes remote control in the CLI. If your server does not issue short links, share the connection command for the recipient's operating system.

  3. Start assisting: Once the device connects, tell the agent what to do. The other person can see commands and output and disconnect at any time.

Connections grant terminal access with the target computer's current user permissions. Only authorize people you trust.

Related MCP server: Codex SSH Terminal MCP

💡 When to use it

  • Help a colleague or customer troubleshoot: Let your agent inspect the remote environment and logs without passing commands and output back and forth.

  • Help family with computer problems: Once they run the client and authorize access, use your familiar agent to assist through the terminal.

  • Work on another development machine or server: Keep using your existing agent without configuring a full agent and model account on the target machine.

  • Check multiple computers: Connect test machines, inspect their environments, and summarize the results.

Interactive terminal tasks are supported. Use the Rust CLI on the target computer to follow progress; the client automatically attempts to reconnect after temporary network failures.

🔗 How it works

Terminal commands and results pass through the server as shown above. The target computer makes an outbound connection after its user authorizes access. Optional P2P file transfers use a separate direct connection between devices, with the server handling signaling. File transfer guide

Use the hosted service or deploy your own server.

☁️ One-Click Deploy

Deploy on RepoCloud

❓ FAQ

Check that both sides can reach the service. If an invitation no longer works, ask the agent to create a new one. For version mismatches, use the server and client from the same release. Connection troubleshooting.

The client attempts to reconnect but does not replay commands. Ask the agent to check the device and task state. Connecting a device does not wake an agent conversation that has already ended.

Agenterm provides terminal assistance, not a remote desktop. Ask the agent for a multi-device invitation to work across computers. Windows supports simple interactive prompts; full-screen programs requiring a real terminal may not work.

Management access currently requires no authentication. The number of online devices is limited per invitation creator's IP address. The agent, server, and target client can see commands and output, so keep invitations and tokens private. Use HTTPS when self-hosting publicly.

User guide · Deployment and source builds · Report an issue · Apache-2.0

Available Tools

7 tools
create_clientA

Create a client connection token and a 15-minute invitation. Set multi_device=true for multiple simultaneous devices and a reusable invitation; otherwise the invitation is single-use and only one device may connect. First show display_text including both platform commands in a progress message, then follow next_action: call list_clients with client_token and wait_ms=20000 repeatedly until a device connects, the invitation expires, or the user cancels. Do not end the turn after showing the invitation or after an empty result. Immediately notify the user when a device connects. Use client_id to target devices for multi-device tokens. Session tools use session_id after starting a session. Treat tokens and commands as credentials and share privately. Saying you are waiting is insufficient: the same response must actually call list_clients; invitation creation alone does not complete this task.

Inputs: multi_device. Returns: expires_at, invitation, next_action, client_token, +4 more

execute_commandA
Destructive

Run a non-interactive shell command on the selected authorized target device and wait for completion. This can modify or delete files and perform any operation allowed to the target user; obtain user approval for destructive commands. client_token is required with management access (including stdio and no-password mode); client_id is required for multi-device tokens. Each call starts a fresh shell: set cwd and env explicitly; changes do not persist between calls. timeout_ms defaults to 60000 (60 seconds), 0 disables the timeout, and the maximum is 86400000 (24 hours). Captured stdout and stderr share a 1 MiB limit; excess output is discarded and truncated=true. The result contains stdout, stderr, exit_code, timed_out, canceled, truncated and optional error; a nonzero exit, timeout, cancellation or execution failure sets isError. Canceling the MCP request sends a best-effort cancellation request; it does not undo effects already performed. Commands are not automatically retried. Use session_start/read/write/stop for prompts, incremental output or long-running jobs.

Inputs: command (required), client_token (required), cwd, env, +2 more. Returns: error, stderr, stdout, canceled, +3 more

list_clientsA
Read-onlyIdempotent

List online devices belonging to this client_token. Set wait_ms=20000 to wait server-side while no device is online; a connection returns immediately. After creating an invitation, show display_text in a progress message and keep calling with wait_ms=20000 until the target connects, the invitation expires, or the user cancels. An empty result is only a wait timeout: continue waiting without ending the turn or asking the user to check. Immediately notify the user when connected. With wait_ms omitted or 0, return a snapshot immediately. Use client_id to execute commands or start sessions. For multi-device tokens, any online device completes the wait; use snapshots to discover additional devices.

Inputs: client_token (required), wait_ms. Returns: status, clients, next_action

session_readA
Read-onlyIdempotent

Read incremental output and terminal state for an owned session. This does not send input or stop the process. Start with cursor=0, then use the returned next_cursor on each read; cursors are byte offsets, not character counts. wait_ms is 0-20000 (default 0): return immediately for new output or a terminal state, otherwise wait up to that many milliseconds. Empty output with done=false is only a polling timeout; continue polling. If older output was dropped from the 1 MiB buffer, truncated=true and reading resumes at the earliest retained byte; a cursor beyond available output is an error. done=true means a terminal result or a closed connection; only then are exit_code, timed_out, canceled and optional error included. A disconnect error is not proof of a remote command's success or confirmed cancellation. Use session_stop to terminate and session_write to supply input. Finished records expire after 30 minutes and server restarts invalidate them.

Inputs: session_id (required), client_token (required), cursor, wait_ms. Returns: done, error, output, canceled, +5 more

session_startA
Destructive

Start a new interactive terminal process on an authorized target device. The command can change files or system state with the target user's permissions. Supply client_id for multi-device tokens; set cwd and env for this new process. timeout_ms defaults to 0 (no timeout), with a maximum of 86400000 (24 hours). Returns session_id and the initial byte cursor 0, not command completion. Repeated calls start separate processes. Use session_read with the last next_cursor to collect incremental output until done=true, session_write to answer prompts (include a newline), and session_stop to cancel. Each token retains up to six sessions, and only the latest 1 MiB of each session's output is retained. Finished history expires after 30 minutes or can be evicted by later sessions; keep the session_id and poll promptly. Server restarts invalidate sessions. For a short non-interactive command with a final stdout/stderr result, use execute_command instead.

Inputs: command (required), client_token (required), cwd, env, +2 more. Returns: cursor, session_id

session_stopA
DestructiveIdempotent

Request termination of a terminal session created by session_start. Requires its session_id and, with management access (including stdio and no-password mode), its owning client_token; it cannot stop a session owned by another token. Stopping can interrupt writes and lose unsaved work, and cannot undo completed side effects. wait_ms defaults to 1000 and can be 0-20000: 0 returns immediately after sending the request, otherwise wait up to that many milliseconds for a terminal result. accepted=true means a stop request was sent or is already pending, not that termination is confirmed. status=stopping and done=false require polling session_read until done=true; use its output/cursor to collect final output. status=stopped requires a terminal canceled=true report. status=finished means the session ended for another reason; inspect canceled, timed_out, exit_code and error, especially on disconnect. Repeating a stop is safe: an already-ended session returns already_done=true and accepted=false without sending another request. Unknown or unauthorized session IDs are errors. Use session_read to observe progress and session_write for input; stopping does not revoke the device token or disconnect other sessions.

Inputs: session_id (required), client_token (required), wait_ms. Returns: done, error, status, accepted, +6 more

session_writeA
Destructive

Send text to the stdin of an owned running terminal session. Include a newline (for example, "yes\n") to submit an answer or command. Input can trigger destructive operations and may be echoed in session output, including secrets; only send input the user authorized. accepted=true confirms the input was sent to the device connection, not that the program consumed it or completed an action. Use session_read afterward to observe the response. Repeating a write sends the input again, so do not retry blindly. Unknown, unauthorized or ended sessions are errors. This does not start a session or cancel it; use session_start or session_stop for those operations.

Inputs: input (required), session_id (required), client_token (required). Returns: accepted

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.5/5.0

    Scored across 7 tools

    Disambiguation5/5

    Each tool targets a distinct part of the remote-terminal workflow: client onboarding, device listing, non-interactive command execution, and session start/read/write/stop. The only possible overlap is execute_command versus session_start, but the descriptions clearly separate short non-interactive commands from interactive long-running sessions.

    Naming Consistency4/5

    The session tools consistently use resource-prefixed action names (session_start, session_read, session_write, session_stop), while client and command tools use verb_noun names (create_client, list_clients, execute_command). This is readable and predictable overall, but the mixed prefix convention keeps it from being perfectly uniform.

    Tool Count5/5

    Seven tools is well-scoped for a remote terminal/device management server. The set covers client setup, device discovery, command execution, and the full interactive session lifecycle without redundant tools.

    Completeness4/5

    Core workflows are covered: creating invitations, waiting for devices, executing commands, and managing interactive sessions. Minor lifecycle gaps remain, such as revoking client tokens or listing existing sessions, but agents can largely work around these.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      C
      maintenance
      MCP server for SSH and local terminal access. Supports interactive commands, long-running processes, and TUI apps like tmux/zellij
      6
      4
      MIT
    • A
      license
      B
      quality
      D
      maintenance
      Agent-native SSH control plane with a local Web Terminal, human-in-the-loop secret input, keychain-backed profiles, and user-confirmed uploads for Codex, Claude Code, and MCP-compatible coding agents.
      18
      1
      Apache 2.0
    • A
      license
      Not graded
      quality
      B
      maintenance
      Turns your own VPS into an agent's remote computer, exposing shell and code execution, persistent workspace files, Bash PTYs, a Chromium browser, notes, scheduled tasks, and a streamed Linux desktop over MCP. Clients such as Claude Code or Codex can also use an authenticated REST API, CLI, and web console to drive the same shared workspace.
      15 npm
      26
      MIT
    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables remote control of a Windows, Linux, or macOS computer directly from an AI chat client over a self-hosted MCP endpoint, providing file management, terminal command execution, and system status monitoring through a relay-and-agent architecture secured by OAuth and device pairing.
      MIT