Skip to main content
Glama

Server Details

Securely control computers you explicitly pair through files, terminals, processes, screenshots, desktop UI/input, clipboard, browser automation, diagnostics, and document tools.

Ownership verified
Status
Healthy
Uptime
95.5% over the last 24 hours
OAuth
Works in Glama
Last Tested
Transport
Streamable HTTP · MCP 2025-11-25
URL
ChatGPT
–
Claude
–

TDQS

B3.4/5.0

Scored across 178 tools

Disambiguation2/5

The surface contains many overlapping families: ui_click/computer_click/pointer_click, ui_invoke/computer_invoke, ui_set_value/computer_set_value, and browser_scroll_into_view/ui_scroll_into_view/computer_scroll_into_view all target similar actions. Descriptions add useful caveats, but the boundaries between the duplicated accessibility/desktop/browser families remain hard to infer reliably. Several descriptions also refer to browser_action or ui_action, which are not in the exposed tool list, increasing selection confusion.

Naming Consistency3/5

Most names use snake_case and follow a verb_noun or resource_action pattern, but there are bare noun tools such as environment, notification, keyboard, and scroll, plus inconsistencies like take_screenshot versus screenshot_region. The many category prefixes are readable, though duplicate concepts are split across ui_, computer_, pointer_, and browser_ prefixes. Overall it is mixed but not chaotic.

Tool Count1/5

At 178 tools this is far beyond a well-scoped surface, even for a broad remote-computer-control server. The extensive duplication among ui_, computer_, pointer_, app_, and browser_ operations makes the set feel accumulated rather than deliberately scoped. This is an extreme count mismatch.

Completeness5/5

The server covers an unusually wide lifecycle: device pairing, browser automation, native UI interaction, files, archives, documents, PDFs, spreadsheets, processes, services, network inspection, power control, audio, clipboard, and configuration/statistics. Major remote-control workflows have corresponding tools, and obvious dead ends are mostly absent. The main issue is overcoverage and duplication, not missing operations.

Publisher details

Operator
ReMCP · Publisher source
Vendor relationship
First-party · Publisher source
Privacy policy
Not provided
Trust center
Not available
Restrictions
Requires signing in to ReMCP and pairing at least one device. Desktop and browser-control features depend on the paired device's OS permissions and advertised capabilities. · Publisher source

Available Tools

178 tools
app_actionFill browser fields or perform a supported app taskA
Destructive
Inspect

Use this when the user needs to fill 1–20 form fields in one selected Chromium tab or perform one supported application task on a paired computer. Browser form writes verify the exact origin, specified prior field values and resulting values. App tasks use the existing scoped permissions. Changes require commit=true and a unique operation_id UUID; otherwise the tool previews the action. Read-only inspections do not require commit. It does not automatically submit forms or run arbitrary scripts or commands.

Inputs: mode (required), device (required), task, commit, +7 more. Returns: data, text

app_catalogApplication GUI catalogA
Read-onlyIdempotent
Inspect

Use this when the user needs to discover curated workflows and, with include_detected=true, new OS software records. Linux prefers visible XDG GUI launchers; macOS .app copies have separate IDs and require PID executable provenance; Windows uses local Start Menu shortcuts with exact PID executable attestation; registry-only rows cannot authorize GUI access. Detection is not proof of an active GUI, permissions or a trusted connector. Use local- ids for inspect/find-visible-controls or explicit checked focus_control and one bounded set_control_text with old-value CAS; other effects are forbidden.

Inputs: device (required), app, filter, refresh, +4 more. Returns: data, text

apply_patchApply patchA
Destructive
Inspect

Use this when you already have a unified diff with one or more hunks and want to apply it to one or several files. Do not use write_file for the same patch-shaped change, and prefer edit_block when the change is one exact text block rather than a diff.

Inputs: patch (required), device (required), path, dry_run. Returns: data, text

app_navigateNavigate system or applicationBInspect

Use this when the task calls for a registered app destination or native system settings panel when one safe route can replace multiple clicks; call app_catalog first and verify the opened UI with ui_snapshot.

Inputs: device (required), destination (required), app, pid, +9 more. Returns: data, text

app_taskUnified application taskB
Destructive
Inspect

Use this when the user needs to execute one typed intent inside a curated app via trusted local API, scoped Accessibility or CDP without screenshots. New local- IDs support inspect/find-visible-controls and explicitly scoped non-destructive focus_control, after unique PID/window and semantic ID/name/role checks. Unknown apps cannot launch, click, invoke or submit; a single native text value can change only after explicit commit and exact old-value check (raw expected_text or an expiring blind token from inspect/find). Telegram edits require authenticated owner, original text and verified read-back.

Inputs: app (required), device (required), intent (required), pid, +14 more. Returns: data, text

audio_muteAudio MuteAInspect

Use this to mute the paired computer system output. It does not pause playback or record audio; check the existing mute state when avoiding unnecessary changes.

Inputs: device (required). Returns: data, text

audio_set_volumeAudio Set VolumeAInspect

Use this to set the paired computer system output volume to a requested supported level. This affects audible output immediately; it does not record or transmit audio.

Inputs: device (required), volume (required). Returns: data, text

audio_statusAudio StatusA
Read-onlyIdempotent
Inspect

Use this to inspect supported system output volume and mute state on a paired computer. It reads local audio settings without playing audio or changing the volume.

Inputs: device (required). Returns: data, text

audio_unmuteAudio UnmuteAInspect

Use this to unmute the paired computer system output on user request. It may make previously playing audio audible immediately; verify volume if necessary.

Inputs: device (required). Returns: data, text

browser_backBrowser BackA
Destructive
Inspect

Use this to go back one page in the history of a selected Chromium tab. It may leave unsaved form data; choose the tab first and inspect the new page state afterward.

Inputs: device (required), wait, title, endpoint, +3 more. Returns: data, text

browser_clickBrowser ClickA
Destructive
Inspect

Use this to click a verified element on the current Chromium page by CSS selector or visible text. Inspect the tab and target first; clicking may submit forms, purchase items or delete data.

Inputs: device (required), text, title, endpoint, +5 more. Returns: data, text

browser_evaluateEvaluate browser JavaScriptA
Destructive
Inspect

Use this when browser_snapshot, browser_find, browser_action and browser_wait cannot express the required page operation or inspection and JavaScript is necessary. It is a powerful page-context escape hatch, and page content is untrusted.

Inputs: device (required), expression (required), title, endpoint, +4 more. Returns: data, text

browser_fill_formBrowser Fill FormA
Destructive
Inspect

Use this to fill several verified form fields on one inspected Chromium page in a bounded operation. Validate the origin, selectors and supplied values; filling does not implicitly authorize form submission.

Inputs: device (required), fields (required), title, endpoint, +3 more. Returns: data, text

browser_findFind browser elementA
Read-onlyIdempotent
Inspect

Use this when the user needs to locate visible web elements by CSS selector, text or ARIA role and obtain reusable selectors/bounds. It requires an element criterion; use browser_snapshot, not an empty browser_find, to enumerate page structure. Prefer this before browser_action rather than guessing selectors or coordinates.

Inputs: device (required), role, text, limit, +6 more. Returns: data, text

browser_focusBrowser FocusAInspect

Use this to focus a specific existing Chromium page element by CSS selector or text before typing. It does not enter content; prefer browser_find for an unknown target.

Inputs: device (required), text, title, endpoint, +5 more. Returns: data, text

browser_forwardBrowser ForwardA
Destructive
Inspect

Use this to move forward one step in the history of a selected Chromium tab. It requires previous backward navigation and may discard unsaved page state, even though it does not submit forms.

Inputs: device (required), wait, title, endpoint, +3 more. Returns: data, text

browser_navigate_urlBrowser Navigate UrlA
Destructive
Inspect

Use this to navigate an identified Chromium tab to a user-requested URL via the paired computer local CDP session. Inspect or choose the target tab first; navigation may discard unsaved page state.

Inputs: url (required), device (required), wait, title, +4 more. Returns: data, text

browser_new_tabBrowser New TabAInspect

Use this to open a specified URL in a new Chromium browser tab on the paired computer. This does not navigate an existing tab; the URL is subject to browser security restrictions.

Inputs: url (required), device (required), wait, title, +4 more. Returns: data, text

browser_pressBrowser PressA
Destructive
Inspect

Use this to send an explicit keyboard key or shortcut to the current inspected Chromium tab, such as Enter or Escape. Enter can submit forms; validate focus and user intent first.

Inputs: key (required), device (required), title, endpoint, +3 more. Returns: data, text

browser_reloadBrowser ReloadA
Destructive
Inspect

Use this to reload an identified Chromium tab, optionally bypassing cache. Reloading may lose unsaved form state; use a browser snapshot to verify the resulting page.

Inputs: device (required), wait, title, endpoint, +4 more. Returns: data, text

browser_scrollBrowser ScrollAInspect

Use this to scroll an identified Chromium tab by a bounded amount or direction. This changes the viewport only; use scroll_into_view when a known target element should become visible.

Inputs: device (required), delta, title, delta_x, +7 more. Returns: data, text

browser_scroll_into_viewBrowser Scroll Into ViewAInspect

Use this to scroll a specified Chromium page element into view using its verified selector or visible text. It does not click the element or change its value.

Inputs: device (required), text, title, endpoint, +5 more. Returns: data, text

browser_selectBrowser SelectA
Destructive
Inspect

Use this to select an option from a native HTML select control on an inspected Chromium page. Verify the selector and valid option first; selection can trigger dependent form updates.

Inputs: device (required), text, title, option, +6 more. Returns: data, text

browser_set_valueBrowser Set ValueA
Destructive
Inspect

Use this to set a specific Chromium form field value through guarded DOM interaction rather than individual keystrokes. Inspect the page and selector first; changing the field can trigger page events.

Inputs: device (required), text, title, value, +6 more. Returns: data, text

browser_set_viewportBrowser Set ViewportAInspect

Use this to change an inspected Chromium tab viewport width, height and optional mobile scale for responsive testing. It changes browser emulation, not the host monitor resolution.

Inputs: width (required), device (required), height (required), title, +6 more. Returns: data, text

browser_snapshotBrowser snapshotA
Read-onlyIdempotent
Inspect

Use this when the user needs to inspect a web page structurally through CDP accessibility. Reuse the last snapshot_id as diff_from to return changed/removed semantic nodes rather than retransmitting the whole page after each step; refresh with a full snapshot when unavailable. Prefer it over desktop ui_snapshot for page content; add include_screenshot=true only when final pixel/layout verification is needed. A selector may be temporarily centered for capture, but the original page scroll position is restored before the tool returns.

Inputs: device (required), title, endpoint, selector, +6 more. Returns: data, text

browser_tabsBrowser tabsA
Read-onlyIdempotent
Inspect

Use this when the user needs browser tabs: List debuggable Chromium tabs when CDP is known ready. If uncertain, first check computer_snapshot(browser_readiness=true, include_ui=false, include_screenshot=false, include_browser=false). When not ready, use native ui_snapshot/ui_find rather than retrying the unchanged endpoint. This read-only tool never launches a browser; use target_id/title/url returned for subsequent browser tools.

Inputs: device (required), title, endpoint, target_id, +2 more. Returns: data, text

browser_typeBrowser TypeA
Destructive
Inspect

Use this to enter user-provided text into a verified Chromium page field, optionally clearing existing text. Confirm the origin and field first; do not put sensitive data into an untrusted page.

Inputs: text (required), device (required), clear, title, +6 more. Returns: data, text

browser_uploadBrowser UploadA
Destructive
Inspect

Use this to attach a user-authorized local file to an inspected Chromium file-input element. Check the exact file path, site origin and target input first; the page may receive the file contents.

Inputs: device (required), selector (required), path, paths, +5 more. Returns: data, text

browser_waitWait for browserA
Read-onlyIdempotent
Inspect

Use this when browser navigation or an action must be followed by proof of selector/text/URL/load/navigation/network-idle instead of fixed sleeps or screenshot polling. Use browser_evaluate separately for JavaScript predicates.

Inputs: device (required), text, title, value, +8 more. Returns: data, text

browser_workflowBrowser WorkflowA
Destructive
Inspect

Use this for an explicitly requested sequence of 1–12 guarded DOM actions and bounded waits on one inspected Chromium page. Validate CSS selectors first. The workflow cannot run arbitrary JavaScript, upload files, switch origins or implicitly submit a form; an explicit click may submit data or cause irreversible remote changes. Stop at the first failed step and never echo field values.

Inputs: steps (required), device (required), title, endpoint, +3 more. Returns: data, text

clipboard_clearClipboard ClearA
Destructive
Inspect

Use this to clear the paired computer clipboard on user request, for example after handling sensitive copied text. This irreversibly removes its current contents from the clipboard.

Inputs: device (required). Returns: data, text

clipboard_readClipboard ReadA
Read-onlyIdempotent
Inspect

Use this when the user asks to inspect the current clipboard text on a paired computer. Clipboard contents may be sensitive; read them only when needed and do not send them to unrelated sites.

Inputs: device (required). Returns: data, text

clipboard_writeClipboard WriteA
Destructive
Inspect

Use this to place user-authorized text on the paired computer clipboard for pasting into an application. This overwrites the previous clipboard contents but does not itself paste or submit data.

Inputs: text (required), device (required). Returns: data, text

computer_add_to_selectionComputer Add To SelectionA
Destructive
Inspect

Use this to add an identified native list or tree item to an existing multi-selection without replacing the other selected items. Confirm the target and current selection first.

Inputs: device (required), x, y, id, +14 more. Returns: data, text

computer_clickComputer ClickA
Destructive
Inspect

Use this to click an identified native desktop control or screen coordinate on a paired computer after inspecting the current UI. Clicking can submit forms, activate buttons or change data; use a semantic target when available.

Inputs: device (required), x, y, id, +14 more. Returns: data, text

computer_collapseComputer CollapseB
Destructive
Inspect

Use this to collapse an identified expanded tree item, menu or disclosure control. Inspect the target first and avoid hiding information needed for the next action.

Inputs: device (required), x, y, id, +13 more. Returns: data, text

computer_dragComputer DragA
Destructive
Inspect

Use this for a real drag-and-drop or selection gesture between verified native desktop elements or screen coordinates. Confirm the source and destination first; dropping can move files or change application state.

Inputs: device (required), x, y, id, +22 more. Returns: data, text

computer_expandComputer ExpandA
Destructive
Inspect

Use this to expand an identified native tree item, menu or disclosure control. This reveals child controls and may trigger application-side effects depending on the target.

Inputs: device (required), x, y, id, +13 more. Returns: data, text

computer_focusComputer FocusAInspect

Use this to bring an identified native desktop control into focus before typing or interacting with it. Prefer a current semantic target; focusing alone does not type text or activate a button.

Inputs: device (required), x, y, id, +13 more. Returns: data, text

computer_invokeComputer InvokeA
Destructive
Inspect

Use this when the user asks to activate an identified native desktop accessibility control on a paired computer, such as invoking a menu item or button. Resolve the intended control from a recent computer_snapshot or ui_find first. Invoking it can submit forms, change application state, or trigger irreversible actions; it does not run arbitrary shell commands or page JavaScript.

Inputs: device (required), x, y, id, +13 more. Returns: data, text

computer_multi_editComputer Multi EditA
Destructive
Inspect

Use this for a bounded batch of native accessibility edits on already identified desktop controls. Verify each requested change and target before applying; individual edits can change application data.

Inputs: edits (required), device (required), x, y, +14 more. Returns: data, text

computer_multi_selectComputer Multi SelectA
Destructive
Inspect

Use this to select multiple verified native desktop items as one semantic accessibility operation. Supply identified targets from a fresh snapshot; selection alone does not open or delete files.

Inputs: device (required), targets (required), x, y, +14 more. Returns: data, text

computer_remove_from_selectionComputer Remove From SelectionA
Destructive
Inspect

Use this to remove an identified native list or tree item from the current multi-selection while preserving remaining selections. It does not delete the underlying item.

Inputs: device (required), x, y, id, +14 more. Returns: data, text

computer_scrollComputer ScrollAInspect

Use this to scroll the native desktop viewport or an identified UI region by a bounded direction or delta. It moves the visible viewport and does not edit document contents.

Inputs: device (required), x, y, id, +18 more. Returns: data, text

computer_scroll_into_viewComputer Scroll Into ViewBInspect

Use this to bring an identified native accessibility element into the visible viewport before reading or interacting with it. This scrolls the interface without editing its data.

Inputs: device (required), x, y, id, +13 more. Returns: data, text

computer_selectComputer SelectB
Destructive
Inspect

Use this to select an identified option or item in a native desktop accessibility control. Inspect the control and its available values first; selection may update application state.

Inputs: device (required), x, y, id, +14 more. Returns: data, text

computer_set_range_valueComputer Set Range ValueB
Destructive
Inspect

Use this to set a numeric or range control, such as a slider, to a specific supported value on the paired desktop. Inspect the control limits first; changing it can affect application settings.

Inputs: device (required), x, y, id, +14 more. Returns: data, text

computer_set_valueComputer Set ValueA
Destructive
Inspect

Use this to assign a specified value to an identified native accessibility control, such as an editable text field. Validate the target before writing; this changes the control rather than sending a keyboard shortcut.

Inputs: device (required), x, y, id, +14 more. Returns: data, text

computer_snapshotComputer snapshotA
Read-onlyIdempotent
Inspect

Use this when you need the first compact view of an unfamiliar desktop state, including windows, semantic UI, displays, clipboard metadata and optional pixels/browser/OCR. Prefer it over repeated screenshots; narrow later with ui_find, browser_find or screenshot_region.

Inputs: device (required), ocr_psm, ui_scope, grid_rows, +19 more. Returns: data, text

computer_toggleComputer ToggleA
Destructive
Inspect

Use this to change the state of a native checkbox, switch or toggle identified through the current desktop snapshot. Check its current state to avoid unintended changes; toggles can alter application settings.

Inputs: device (required), x, y, id, +13 more. Returns: data, text

computer_typeComputer TypeA
Destructive
Inspect

Use this to enter user-provided text into a focused or identified native desktop control, optionally clearing its previous value. First confirm the target from the current UI; never type passwords or private data into an unverified field.

Inputs: text (required), device (required), x, y, +15 more. Returns: data, text

copy_fileCopy fileA
Destructive
Inspect

Use this when the user asks to copy exactly one regular file to a new path on the same computer. For directories or two or more copies use copy_paths.

Inputs: device (required), source (required), destination (required), overwrite. Returns: data, text

copy_pathsCopy pathsA
Destructive
Inspect

Use this when the user asks to copy a directory recursively or two or more paths in one request. For exactly one regular file use copy_file.

Inputs: paths (required), device (required), overwrite. Returns: data, text

create_archiveCreate archiveA
Destructive
Inspect

Use this when the user wants files or a directory packed into a tar, tar.gz, or zip archive, for example before a transfer or a backup.

Inputs: paths (required), device (required), destination (required), format. Returns: data, text

create_directoryCreate directoriesA
Idempotent
Inspect

Use this when the user asks to create a directory, including any missing parent directories.

Inputs: device (required), path, paths. Returns: data, text

create_pairing_commandConnect a new computerA
Idempotent
Inspect

Use this when the person wants to connect another computer to their ReMCP account, or asks how to add a device: returns platform-specific Windows/macOS/Linux commands, the pairing code, and when it expires. Windows uses the no-prerequisite PowerShell bootstrap; macOS/Linux use the npm launcher. The same commands are returned while the code is still valid.

Inputs: no named parameters. Returns: data, text

delete_pathDelete pathA
Destructive
Inspect

Use this when the user explicitly asks to remove exactly one file or directory and does not need it recoverable. Use delete_paths for two or more targets, or move_to_trash when reversibility matters.

Inputs: path (required), device (required), recursive. Returns: data, text

delete_pathsDelete pathsA
Destructive
Inspect

Use this when the user explicitly asks to remove two or more named files or directories in one batch. For one target use delete_path; use move_to_trash when reversibility matters.

Inputs: paths (required), device (required), recursive. Returns: data, text

diff_filesDiff filesA
Read-onlyIdempotent
Inspect

Use this when the user wants to see how two text files differ, before or after a change.

Inputs: left (required), right (required), device (required), context_lines. Returns: data, text

disable_deviceDisable paired computerA
Destructive
Inspect

Use this when the user needs to disable an existing paired computer only when the user explicitly requests it. Disconnects the pairing until re-enabled; requires its device id.

Inputs: device (required). Returns: data, text

display_inventoryDisplay inventoryA
Read-onlyIdempotent
Inspect

Use this when monitor-specific screenshots, cross-monitor geometry or coordinate work require monitor bounds, scale and primary-display information.

Inputs: device (required). Returns: data, text

document_append_paragraphDocument Append ParagraphB
Destructive
Inspect

Use this to append a user-provided paragraph to a specified local word-processing document. Verify the path and creation option; this writes document content.

Inputs: path (required), text (required), device (required), create, +1 more. Returns: data, text

document_delete_paragraphDocument Delete ParagraphA
Destructive
Inspect

Use this to delete one or more paragraphs matching requested text in a specified local word-processing document. This removes document content; confirm the exact match and backup needs.

Inputs: path (required), device (required), search (required), all, +2 more. Returns: data, text

document_insert_paragraph_afterDocument Insert Paragraph AfterA
Destructive
Inspect

Use this to insert a new paragraph after an identified matching paragraph in a specified local document. Confirm the search target and intended location before writing.

Inputs: path (required), text (required), device (required), search (required), +2 more. Returns: data, text

document_insert_paragraph_beforeDocument Insert Paragraph BeforeA
Destructive
Inspect

Use this to insert a new paragraph before an identified matching paragraph in a specified local document. Check the match and the text before writing.

Inputs: path (required), text (required), device (required), search (required), +2 more. Returns: data, text

document_prepend_paragraphDocument Prepend ParagraphB
Destructive
Inspect

Use this to insert a user-provided paragraph at the beginning of a specified local word-processing document. Confirm the document path and preserve existing content.

Inputs: path (required), text (required), device (required), create, +1 more. Returns: data, text

document_replaceDocument ReplaceA
Destructive
Inspect

Use this to replace specified matching text in a user-selected local word-processing document. Check the search string, replacement and destination; edits change document content.

Inputs: path (required), device (required), search (required), replacement (required), +3 more. Returns: data, text

drag_dropDrag and dropA
Destructive
Inspect

Use this when the task calls for a real drag gesture between two UI element ids or coordinates. Prefer element ids from ui_find/ui_snapshot because their current bounds are resolved at execution time; use coordinates only when no semantic endpoints exist. On GNOME Wayland, real drag input requires the consent-backed Remote Desktop portal because XTEST/xdotool drag delivery is not reliable.

Inputs: device (required), to_x, to_y, to_id, +7 more. Returns: data, text

edit_blockEdit fileA
Destructive
Inspect

Use this when one known text block in one file should be replaced, with a whitespace-tolerant fallback and optional dry-run diff. Use write_file only when replacing the whole file, and replace_lines when the intended target is a known line range rather than matching text.

Inputs: device (required), file_path (required), new_string (required), old_string (required), +3 more. Returns: data, text

edit_spreadsheetEdit spreadsheetA
Destructive
Inspect

Use this when the user needs to create a new XLSX workbook or directly edit XLSX cells/ranges/formulas without launching Excel. Set create=true only for a new path; it fails rather than overwriting an existing workbook. Prefer explicit cells/ranges and write to output when preserving an existing original matters.

Inputs: path (required), edits (required), device (required), sheet, +2 more. Returns: data, text

enable_deviceEnable paired computerAInspect

Use this when the user needs to enable an existing paired computer only when the user explicitly requests it. Changes that pairing to enabled; requires its device id.

Inputs: device (required). Returns: data, text

environmentRuntime environmentA
Read-onlyIdempotent
Inspect

Use this when the task calls for PATH, shell, Node/runtime environment paths, architecture and optionally sanitized environment variables. Use get_system_info for host health such as CPU/memory/disk/uptime, and get_runtime_info for ReMCP policy, roots and limits. Secret-looking values remain masked.

Inputs: device (required), include_env. Returns: data, text

event_logEvent logsA
Read-onlyIdempotent
Inspect

Use this when the user needs to read bounded recent OS logs (Windows Event Log, macOS unified log or systemd journal) when diagnosing a service/app/system problem. Prefer it over an unbounded shell log dump.

Inputs: device (required), log, limit, query, +2 more. Returns: data, text

extract_archiveExtract archiveA
Destructive
Inspect

Use this when the user wants an existing tar or zip archive unpacked on a paired computer.

Inputs: device (required), archive (required), destination. Returns: data, text

force_terminateStop sessionA
Destructive
Inspect

Use this when a process session created by start_process must stop, such as a runaway build or server left behind. For an arbitrary operating-system PID that is not a ReMCP terminal session, use kill_process instead.

Inputs: pid (required), device (required). Returns: data, text

get_configurationReMCP configurationA
Read-onlyIdempotent
Inspect

Use this when the person asks how the hosted ReMCP deployment/account is configured: server version and endpoint, runtime release installed on devices, retention/telemetry policy, hosted limits, and paired-computer versions. Use get_runtime_info for one computer's local runtime roots, policy and limits; use get_system_info for that computer's OS/CPU/memory/disk state.

Inputs: no named parameters. Returns: data, text

get_file_infoGet file infoA
Read-onlyIdempotent
Inspect

Use this when the user needs the size, type, permissions, or modification time of one file or directory before deciding what to do with it.

Inputs: path (required), device (required). Returns: data, text

get_more_search_resultsGet more search resultsA
Read-onlyIdempotent
Inspect

Use this when a search started with start_search still has more matches to return.

Inputs: device (required), sessionId (required), length, offset. Returns: data, text

get_recent_tool_callsRecent tool callsA
Read-onlyIdempotent
Inspect

Use this when you need to recover recent ReMCP activity or answer what was just done. It returns the most recent tool calls with the computer they ran on, success state and duration.

Inputs: tool, limit, device. Returns: data, text

get_runtime_infoGet runtime infoA
Read-onlyIdempotent
Inspect

Use this when you need one computer's local ReMCP runtime version, guardrails, allowed roots, or configured limits. Use get_system_info for host OS/CPU/memory/disk facts; deployment/account-level ReMCP server configuration belongs to get_configuration.

Inputs: device (required). Returns: data, text

get_runtime_statsGet runtime statsA
Read-onlyIdempotent
Inspect

Use this when you need counters from the current local runtime session on one machine: tool calls, failures, blocks, and active sessions. Account-level historical usage aggregated by device/tool over days belongs to get_usage_statistics.

Inputs: device (required). Returns: data, text

get_system_infoGet system infoA
Read-onlyIdempotent
Inspect

Use this when the user asks about machine health and host facts such as operating system, CPU load, memory, free disk space, or uptime. Use environment for PATH/shell/runtime environment details, and get_runtime_info for ReMCP-specific version, policy, and limits.

Inputs: device (required). Returns: data, text

get_usage_statisticsUsage statisticsA
Read-onlyIdempotent
Inspect

Use this when the person asks for account-level historical ReMCP usage over days: call counts, success rate, average duration, and per-tool/per-device breakdowns. Use get_runtime_stats instead for counters from the current local runtime session on one machine.

Inputs: days, tool, device. Returns: data, text

hash_fileHash fileA
Read-onlyIdempotent
Inspect

Use this when the user wants a checksum to verify a download, compare two files, or confirm a transfer.

Inputs: path (required), device (required), algorithm. Returns: data, text

installed_appsInstalled applicationsA
Read-onlyIdempotent
Inspect

Use this when the user needs to answer what software/packages are installed and their versions. Prefer a filter when looking for one product instead of returning the full inventory.

Inputs: device (required), limit, filter, refresh. Returns: data, text

interact_with_processInteract with processB
Destructive
Inspect

Use this when a running process is waiting for input, such as a prompt or a confirmation.

Inputs: pid (required), input (required), device (required), timeout_ms. Returns: data, text

keyboardKeyboard shortcutA
Destructive
Inspect

Use this when the task calls for shortcuts and individual key presses such as Ctrl/Cmd+C, Tab, Enter or Escape. Do not use it to enter normal prose when type_text is available. On Wayland auto uses an already-authorized portal; backend=portal explicitly requests consent.

Inputs: device (required), app, key, pid, +5 more. Returns: data, text

kill_processKill processA
Destructive
Inspect

Use this when the user wants to stop an arbitrary operating-system process by PID. If the PID belongs to a ReMCP terminal session created by start_process, prefer force_terminate so the session state and process tree are handled consistently.

Inputs: pid (required), device (required). Returns: data, text

launch_appLaunch applicationA
Destructive
Inspect

Use this when the user explicitly asks to start a named desktop application or permitted executable on a paired computer. Launches the specified app with an argument array and no shell; start_process handles shell commands and scripts, while open_path opens existing permitted files or directories in their default application. Starting an app can execute code and change desktop state.

Inputs: device (required), app, cwd, args, +3 more. Returns: data, text

list_devicesList ReMCP devicesA
Read-onlyIdempotent
Inspect

Use this when the target computer is not already unambiguous. Call it first to list computers paired to the signed-in ReMCP account and see which ones are online.

Inputs: no named parameters. Returns: data, text

list_directoryList directoryA
Read-onlyIdempotent
Inspect

Use this when the user wants to see what a directory on a paired computer contains, optionally filtered by a glob.

Inputs: path (required), device (required), depth, pattern. Returns: data, text

list_processesList processesA
Read-onlyIdempotent
Inspect

Use this when the user wants the computer-wide operating-system process list. Use list_sessions when the question is only about commands started through ReMCP start_process.

Inputs: device (required), limit. Returns: data, text

list_searchesList searchesA
Read-onlyIdempotent
Inspect

Use this when you need to know which search sessions are still active on a machine.

Inputs: device (required). Returns: data, text

list_sessionsList sessionsA
Read-onlyIdempotent
Inspect

Use this when you need to know which ReMCP terminal sessions created by start_process are still running. Use list_processes for the computer-wide operating-system process list.

Inputs: device (required). Returns: data, text

list_windowsList windowsA
Read-onlyIdempotent
Inspect

Use this when the user needs to discover top-level desktop windows or obtain a stable window id/PID/bounds before window_action, screenshot_region or targeted input. Use ui_snapshot instead when you need controls inside a window; prefer list_windows over screenshot-based window guessing.

Inputs: device (required), include_monitor. Returns: data, text

move_fileMove or renameA
Destructive
Inspect

Use this when the user asks to move or rename exactly one file or directory from one source to one destination. For two or more moves use move_paths.

Inputs: device (required), source (required), destination (required), overwrite. Returns: data, text

move_pathsMove pathsA
Destructive
Inspect

Use this when the user asks to move or rename two or more files/directories in one batch. For one source/destination pair use move_file.

Inputs: paths (required), device (required), overwrite. Returns: data, text

move_to_trashMove to trashA
Destructive
Inspect

Use this when the user wants a file or directory removed but still recoverable from the system trash.

Inputs: device (required), source (required). Returns: data, text

network_dnsNetwork DnsA
Read-onlyIdempotent
Inspect

Use this when the user asks to inspect the operating system configured DNS resolver server addresses on a paired computer. This reads local DNS configuration only; it performs no DNS lookup, external network request, or network configuration change.

Inputs: device (required). Returns: data, text

network_interfacesNetwork InterfacesA
Read-onlyIdempotent
Inspect

Use this when the user asks to inspect the full local network interface inventory on a paired computer, including OS-reported IPv4 and IPv6 addresses, netmasks, MAC addresses and internal-interface flags. Unlike network_summary, the inventory is not truncated. This only reads local adapter data; it does not scan networks or change network configuration.

Inputs: device (required). Returns: data, text

network_listenersNetwork ListenersA
Read-onlyIdempotent
Inspect

Use this when the user asks to inspect listening ports on a paired computer to diagnose local services, unexpected exposure or port conflicts. Reads the OS TCP listener inventory on Windows and macOS, and TCP/UDP listeners on Linux; process details depend on OS permissions. It does not connect to ports, scan remote hosts or change firewall rules.

Inputs: device (required). Returns: data, text

network_routesNetwork RoutesA
Read-onlyIdempotent
Inspect

Use this when the user asks to inspect the local OS routing table on a paired computer, including default gateway, destination networks, next hops and route metrics where supported. Use it to diagnose routing and reachability issues. The output varies by OS; it does not add routes, send traffic or change network settings.

Inputs: device (required). Returns: data, text

network_summaryNetwork SummaryA
Read-onlyIdempotent
Inspect

Use this when the user asks for a quick network overview of a paired computer: hostname, DNS servers and a bounded sample of its local network interfaces and IP addresses, including counts and truncation flags. Prefer network_interfaces for the complete inventory. This is read-only; it does not probe remote hosts or change network settings.

Inputs: device (required). Returns: data, text

network_testNetwork TestA
Read-onlyIdempotent
Inspect

Use this to check TCP connectivity from a paired computer to a specified host and port with a bounded timeout. It makes an outbound network connection but does not scan ranges or modify network settings.

Inputs: host (required), port (required), device (required), timeout_ms. Returns: data, text

notificationDesktop notificationAInspect

Use this when the user wants a visible native desktop notification on the paired computer. Do not use it as a substitute for replying in chat.

Inputs: device (required), message (required), title, timeout_seconds. Returns: data, text

open_pathOpen pathAInspect

Use this when the user wants the desktop operating system to open an existing permitted file or directory with its configured default application. The path is checked against the paired computer policy.

Inputs: path (required), device (required). Returns: data, text

pdf_annotationsPdf AnnotationsA
Read-onlyIdempotent
Inspect

Use this when the user asks to list or inspect annotations, comments, highlights or markup already present in one permitted local PDF file on a paired computer. Requires the PDF path and only returns annotation metadata; it does not edit, save, delete or annotate the PDF.

Inputs: path (required), device (required). Returns: data, text

pdf_extract_pagesPdf Extract PagesA
Destructive
Inspect

Use this to extract a requested page range from a selected local PDF into an output PDF. Validate page numbers and output path; source pages remain unchanged.

Inputs: path (required), pages (required), device (required), output (required), +2 more. Returns: data, text

pdf_infoPdf InfoA
Read-onlyIdempotent
Inspect

Use this when the user asks to inspect an existing local PDF file on an explicitly paired computer and retrieve its metadata and properties, such as page count, title, author or PDF version when the local pdfinfo utility is available. Supply the permitted PDF path. Without pdfinfo, the fallback reports file size in bytes and annotation count. This is read-only: it does not extract page text, edit annotations, write output or replace the source PDF.

Inputs: path (required), device (required). Returns: data, text

pdf_mergePdf MergeA
Destructive
Inspect

Use this to combine multiple user-selected local PDF files into a new output PDF in specified order. Check every input and destination; this creates an output file but does not edit the source pages.

Inputs: paths (required), device (required), output (required), path, +2 more. Returns: data, text

pdf_splitPdf SplitA
Destructive
Inspect

Use this to split a selected local PDF into separate files or page groups using requested page boundaries. Verify the input and destination directory first; new output files are created.

Inputs: path (required), device (required), pages, output, +2 more. Returns: data, text

ping_devicePing a ReMCP deviceA
Read-onlyIdempotent
Inspect

Use this when you need to check that a paired computer answers right now and measure the round trip. The device agent answers the ping itself, so it works even while the local runtime is restarting or missing, and it reports hostname, platform, uptime and versions.

Inputs: device (required). Returns: data, text

pointer_clickPointer ClickA
Destructive
Inspect

Use this to send one native mouse click at a verified desktop coordinate. Check the current screenshot or element bounds first; clicking can trigger purchases, deletion or other actions.

Inputs: device (required), x, y, button, +1 more. Returns: data, text

pointer_double_clickPointer Double ClickA
Destructive
Inspect

Use this to send a native double-click at a verified desktop coordinate, for example to open a file or application. Inspect the target first; double-clicking may execute an action.

Inputs: device (required), x, y, button, +1 more. Returns: data, text

pointer_downPointer DownA
Destructive
Inspect

Use this when the user asks to press and hold a mouse button to begin a native desktop drag or selection gesture on a paired computer. This sends a real pointer-button-down event to the current application and leaves the button held until pointer_up; it may change application state.

Inputs: device (required), x, y, button, +1 more. Returns: data, text

pointer_movePointer MoveAInspect

Use this to move the desktop mouse pointer to a requested coordinate without clicking. Prefer semantic UI tools for actions; movement alone does not select or submit anything.

Inputs: device (required), x, y, backend. Returns: data, text

pointer_right_clickPointer Right ClickA
Destructive
Inspect

Use this to open a native context menu by right-clicking at a verified coordinate. Inspect the target and resulting menu before selecting any command.

Inputs: device (required), x, y, button, +1 more. Returns: data, text

pointer_upPointer UpA
Destructive
Inspect

Use this when the user asks to release a mouse button after pointer_down during a native desktop drag or selection gesture on a paired computer. Releasing the button can complete a drag, click, selection or application action; it does not press the button.

Inputs: device (required), x, y, button, +1 more. Returns: data, text

power_lockPower LockAInspect

Use this to lock the paired computer screen while keeping the operating system and active applications running. Unlocking requires the device owner credentials.

Inputs: device (required), delay_seconds. Returns: data, text

power_restartPower RestartA
Destructive
Inspect

Use this to reboot the paired computer when explicitly authorized. This ends active sessions and may interrupt unsaved work or remote access; verify necessity first.

Inputs: device (required), delay_seconds. Returns: data, text

power_shutdownPower ShutdownA
Destructive
Inspect

Use this to shut down the paired computer when explicitly authorized. This ends running applications and remote connectivity; the device may require local power-on to reconnect.

Inputs: device (required), delay_seconds. Returns: data, text

power_sleepPower SleepA
Destructive
Inspect

Use this to put the paired computer into system sleep mode when explicitly requested. Remote connectivity and active jobs may become unavailable until the device wakes.

Inputs: device (required), delay_seconds. Returns: data, text

read_binaryRead binary chunkA
Read-onlyIdempotent
Inspect

Use this when the user needs a non-text file transferred or inspected byte for byte as base64 chunks. For a normal image that should be shown or visually inspected, use read_image instead.

Inputs: path (required), device (required), length_bytes, offset_bytes. Returns: data, text

read_documentRead documentA
Read-onlyIdempotent
Inspect

Use this when the user needs structured document content from a PDF, DOCX, XLSX, CSV, JSON or XML file on a paired computer. Returns extracted content and bounded metadata from the document path.

Inputs: path (required), device (required), sheet, max_cells. Returns: data, text

read_fileRead fileA
Read-onlyIdempotent
Inspect

Use this when the task calls for plain text files on a paired computer: source code, configuration, Markdown, logs, scripts, or other line-oriented text. Use read_document instead for PDF, DOCX, XLSX and other structured document content. read_file keeps legacy PDF/DOCX extraction for compatibility but should not be the model’s first choice for those formats.

Inputs: path (required), device (required), length, offset. Returns: data, text

read_filesRead files by globA
Read-onlyIdempotent
Inspect

Use this when the exact file list is not already known and the user wants the contents of every file matching one glob under a directory. Use start_search instead to find filenames or text matches without reading every matched file. If exact paths are already known, use read_multiple_files; for one known path use read_file.

Inputs: device (required), path, pattern, max_files, +2 more. Returns: data, text

read_imageRead imageA
Read-onlyIdempotent
Inspect

Use this when the user wants to inspect or show an image that lives on a paired computer, such as a screenshot, photo, or diagram. It returns native MCP image content; do not use read_binary merely to display an image.

Inputs: path (required), device (required). Returns: data, text

read_multiple_filesRead multiple filesA
Read-onlyIdempotent
Inspect

Use this when the user names two or more exact file paths to read in one call. Do not use it for glob discovery: use read_files instead. For one known path use read_file.

Inputs: paths (required), device (required). Returns: data, text

read_process_outputRead process outputA
Read-only
Inspect

Use this when a process started earlier has more output to show and you do not want to wait for a pattern.

Inputs: pid (required), device (required), length, offset, +1 more. Returns: data, text

record_screenRecord screenA
Destructive
Inspect

Use this when the task calls for a short bounded screen recording when motion/timing is necessary to diagnose a UI issue. Prefer screenshot_region for static visual verification because it is cheaper and easier to inspect.

Inputs: device (required), fps, destination, duration_seconds. Returns: data, text

remove_deviceRemove paired computerA
Destructive
Inspect

Use this when the user needs to permanently remove an existing paired computer only when the user explicitly requests that irreversible action. Revokes the pairing; requires its device id.

Inputs: device (required). Returns: data, text

rename_deviceRename a computerA
Idempotent
Inspect

Use this when the user wants to change the account-visible label of one paired computer. Do not use set_config_value for renaming: that device tool changes local runtime preferences instead. Access roots, command guardrails and resource limits stay on the computer itself.

Inputs: value (required), device (required), config_key (required). Returns: data, text

replace_in_filesReplace in filesA
Destructive
Inspect

Use this when the same text or regular-expression replacement should be searched and applied across multiple files under a path, such as a rename or version bump. For one known block use edit_block; for one complete known file use write_file.

Inputs: path (required), device (required), pattern (required), replacement (required), +4 more. Returns: data, text

replace_linesReplace linesA
Destructive
Inspect

Use this when the intended edit target is a specific 1-based line range in one file, optionally as a dry run. Use edit_block for matching an exact text block and write_file for replacing the complete file.

Inputs: path (required), device (required), content (required), end_line (required), +2 more. Returns: data, text

reveal_pathReveal pathAInspect

Use this when the user needs to reveal a permitted local file or directory in Finder/Explorer/file manager without opening the document itself.

Inputs: path (required), device (required). Returns: data, text

screenshot_regionScreenshot regionA
Read-onlyIdempotent
Inspect

Use this when static pixels are required for visual verification but only one window, monitor or rectangle matters. Prefer it over take_screenshot for a full desktop and over record_screen when motion/timing is not required; use ui_snapshot/browser_snapshot first when semantic structure is sufficient.

Inputs: device (required), x, y, app, +8 more. Returns: data, text

scrollScrollAInspect

Use this when the task calls for native wheel scrolling of a desktop region or semantic UI target. Prefer browser_action scroll_into_view for a known web element and ui_action scroll_into_view for a known accessible desktop element.

Inputs: device (required), x, y, id, +13 more. Returns: data, text

service_listService ListA
Read-onlyIdempotent
Inspect

Use this to list installed OS services on a paired computer for troubleshooting. Returns a local service inventory; it does not start, stop or modify services.

Inputs: device (required), name, scope. Returns: data, text

service_restartService RestartA
Destructive
Inspect

Use this to restart one specifically named OS service on a paired computer when requested. This interrupts the service and can disrupt active users; check scope and recovery expectations first.

Inputs: name (required), device (required), scope. Returns: data, text

service_startService StartA
Destructive
Inspect

Use this to start one specifically named OS service on a paired computer when requested. Starting may launch background processes and change system state; confirm name and scope first.

Inputs: name (required), device (required), scope. Returns: data, text

service_statusService StatusA
Read-onlyIdempotent
Inspect

Use this to inspect the current state of one named OS service on a paired computer. It reads status only and is preferable to service_list when the service name is known.

Inputs: name (required), device (required), scope. Returns: data, text

service_stopService StopA
Destructive
Inspect

Use this to stop one specifically named OS service on a paired computer when requested. Stopping may interrupt users, applications or network availability; confirm the service name and impact first.

Inputs: name (required), device (required), scope. Returns: data, text

set_config_valueChange runtime settingA
Idempotent
Inspect

Use this when the person wants to change a local runtime preference on one computer: telemetry opt-out, read/buffer line limits, or result size. Do not use this for account-level computer administration; ping_device, rename_device, enable_device, disable_device and remove_device cover account-level computer administration. Access roots, blocked commands, shell/guardrails and the write limit stay local-only.

Inputs: key (required), value (required), device (required). Returns: data, text

set_permissionsSet permissionsA
Destructive
Inspect

Use this when the user asks to change mode bits or ownership of a file or directory, for example to make a script executable.

Inputs: mode (required), path (required), device (required), gid, +2 more. Returns: data, text

start_processStart processA
Destructive
Inspect

Use this when the user asks to run a shell command, build, test suite, script, or terminal server that is not already covered by a narrower semantic tool. Prefer launch_app for GUI applications, service for service-manager operations, power_action for lock/sleep/restart/shutdown, network for routine network inspection/tests, event_log for OS logs, installed_apps for software inventory, environment for environment facts, and open_path/reveal_path for opening or revealing files.

Inputs: device (required), command (required), timeout_ms. Returns: data, text

take_screenshotTake screenshotAInspect

Use this when the user needs pixels for the entire desktop. Prefer ui_snapshot or browser_snapshot for semantic inspection, and screenshot_region for one window, monitor, or rectangle.

Inputs: device (required), keep, directory. Returns: data, text

type_textType textA
Destructive
Inspect

Use this when the task calls for reliable Unicode text entry into a native semantic target or focused native control. Prefer method=auto so Accessibility is used when the target supports verified semantic editing. For Chromium page DOM, use browser_action instead of forcing desktop accessibility text input; auto fails safely when a semantic element rejects the write rather than claiming an unverified paste. Use method=keys only for deliberate physical key-by-key input, and keyboard for shortcuts/navigation/control keys.

Inputs: text (required), device (required), id, app, +14 more. Returns: data, text

ui_add_to_selectionUi Add To SelectionB
Destructive
Inspect

Use this to add an identified native UI item to the existing selection through Accessibility/UI Automation without clearing other selected items.

Inputs: device (required), id, app, pid, +5 more. Returns: data, text

ui_clickUi ClickA
Destructive
Inspect

Use this to activate an identified native Accessibility/UI Automation element, such as a button or menu item, after ui_snapshot or ui_find. Clicking can submit data or execute destructive application actions.

Inputs: device (required), id, app, pid, +5 more. Returns: data, text

ui_collapseUi CollapseA
Destructive
Inspect

Use this to collapse an identified native Accessibility/UI Automation tree node or disclosure control. It changes visible UI state without deleting child items.

Inputs: device (required), id, app, pid, +5 more. Returns: data, text

ui_expandUi ExpandA
Destructive
Inspect

Use this to expand an identified native Accessibility/UI Automation tree node or disclosure control to reveal its children. Inspect the current element first.

Inputs: device (required), id, app, pid, +5 more. Returns: data, text

ui_findFind UI elementsA
Read-onlyIdempotent
Inspect

Use this when you need a small set of native UI elements by role/name/label/AutomationId after ui_snapshot. It requires an element criterion; use ui_snapshot, not an empty ui_find, to enumerate UI. Prefer returned id or compact label for subsequent ui_action; refresh only when the UI has changed.

Inputs: device (required), id, app, pid, +9 more. Returns: data, text

ui_focusUi FocusAInspect

Use this to focus an identified native Accessibility/UI Automation field or control prior to keyboard input. It does not insert text; identify the element from a recent snapshot.

Inputs: device (required), id, app, pid, +5 more. Returns: data, text

ui_invokeUi InvokeA
Destructive
Inspect

Use this when the user asks to invoke one identified native Accessibility/UI Automation element, such as a button or menu command, by its element ID or a specific role/name selector on a paired computer. Find the control with ui_snapshot or ui_find first. Invoking a control can submit data or cause destructive application actions.

Inputs: device (required), id, app, pid, +5 more. Returns: data, text

ui_remove_from_selectionUi Remove From SelectionA
Destructive
Inspect

Use this to deselect one identified native UI item through Accessibility/UI Automation without removing the underlying data or clearing all selections.

Inputs: device (required), id, app, pid, +5 more. Returns: data, text

ui_scroll_into_viewUi Scroll Into ViewAInspect

Use this to bring an identified native Accessibility/UI Automation element into view before interacting with it. Prefer semantic targeting over blind pointer scrolling.

Inputs: device (required), id, app, pid, +5 more. Returns: data, text

ui_selectUi SelectA
Destructive
Inspect

Use this to select an option in an identified native Accessibility/UI Automation list or selection control. Verify available options first; selection may change application state.

Inputs: device (required), id, app, pid, +6 more. Returns: data, text

ui_set_range_valueUi Set Range ValueA
Destructive
Inspect

Use this to assign a supported value to an identified native slider or range widget through Accessibility/UI Automation. Inspect allowed bounds first; changes can take effect immediately.

Inputs: device (required), id, app, pid, +6 more. Returns: data, text

ui_set_valueUi Set ValueA
Destructive
Inspect

Use this to replace the value of a native accessible text field or editable control by element ID or semantic selector. Check the target before writing; it may update application data.

Inputs: device (required), id, app, pid, +6 more. Returns: data, text

ui_snapshotUI accessibility snapshotA
Read-onlyIdempotent
Inspect

Use this when the user needs to inspect native desktop Accessibility/UI Automation semantics for the active app before clicking or typing. Prefer scope=active; use scope=desktop only for cross-application discovery. For a Chromium web page with CDP available, prefer browser_snapshot for page DOM semantics.

Inputs: device (required), app, pid, scope, +5 more. Returns: data, text

ui_toggleUi ToggleA
Destructive
Inspect

Use this to activate an identified native checkbox or switch using its accessibility semantics. Check the present state before toggling; this can change saved settings.

Inputs: device (required), id, app, pid, +5 more. Returns: data, text

wait_for_process_outputWait for process outputA
Read-only
Inspect

Use this when you need to wait until a running command prints something specific, such as a readiness line or a failing test name.

Inputs: pid (required), device (required), pattern (required), timeout_ms. Returns: data, text

wait_for_uiWait for UIA
Read-onlyIdempotent
Inspect

Use this when a desktop action must be followed by proof of an explicit native UI state or condition instead of sleeping or polling screenshots. Presence/absence waits need a semantic target; use state=changed for a broad tree change and set a bounded timeout.

Inputs: device (required), id, app, pid, +11 more. Returns: data, text

who_am_iWho am IA
Read-onlyIdempotent
Inspect

Use this when the person asks which ReMCP account they are signed in as, how many machines are paired and online, or how many tool calls they have made lately.

Inputs: no named parameters. Returns: data, text

window_closeWindow CloseA
Destructive
Inspect

Use this to close a specific application window on the paired computer. Closing may discard unsaved changes or quit an application; confirm the intended window and save work first.

Inputs: device (required), id, app, pid, +2 more. Returns: data, text

window_focusWindow FocusAInspect

Use this to activate an existing application window on the paired desktop, identified by a current window ID, process or title. This only changes the active window; use list_windows if the target is unknown.

Inputs: device (required), id, app, pid, +2 more. Returns: data, text

window_maximizeWindow MaximizeAInspect

Use this to maximize an identified application window on the paired desktop. Confirm the target window first; it changes window layout without modifying application files.

Inputs: device (required), id, app, pid, +2 more. Returns: data, text

window_minimizeWindow MinimizeAInspect

Use this to minimize a selected application window while leaving the application running. Identify the window first; it does not close the window or terminate its process.

Inputs: device (required), id, app, pid, +2 more. Returns: data, text

window_moveWindow MoveAInspect

Use this to reposition an identified desktop window to specified screen coordinates. Confirm monitor geometry before moving; the application continues running.

Inputs: x (required), y (required), device (required), id, +4 more. Returns: data, text

window_move_resizeWindow Move ResizeBInspect

Use this to reposition and resize a specific desktop window in one action with explicit coordinates and dimensions. Verify its identity and monitor bounds beforehand.

Inputs: x (required), y (required), width (required), device (required), +6 more. Returns: data, text

window_resizeWindow ResizeAInspect

Use this to resize an identified desktop window to the requested width and height. Inspect display limits first; it does not change the content of files in the application.

Inputs: width (required), device (required), height (required), id, +4 more. Returns: data, text

window_restoreWindow RestoreAInspect

Use this to restore an identified minimized or maximized application window to its normal state. It changes window state but does not restore deleted data.

Inputs: device (required), id, app, pid, +2 more. Returns: data, text

write_binaryWrite binary chunkA
Destructive
Inspect

Use this when the user needs base64 data written to a file on a paired computer byte for byte, including files too large for a single call.

Inputs: data (required), path (required), device (required), mode. Returns: data, text

write_fileWrite fileA
Destructive
Inspect

Use this when the user asks to create or replace the complete contents of exactly one text file. For a small exact-block edit use edit_block, for a known line range use replace_lines, and when you already have a unified diff use apply_patch. For two or more independent complete files use write_files; use write_binary for binary bytes.

Inputs: path (required), device (required), content (required), mode. Returns: data, text

write_filesWrite multiple filesA
Destructive
Inspect

Use this when the user asks to create or replace the complete contents of two or more independent text files in one batch. For one path use write_file; for partial edits use edit_block, replace_lines, replace_in_files, or apply_patch instead of rewriting whole files.

Inputs: files (required), device (required). Returns: data, text

Tool Schema Changelog

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

Loading tool schema changelog…

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables AI assistants like Claude, Codex and ChatGPT to actually operate a computer — finding files, running commands, taking screenshots and driving a browser — and, after a one-time pairing, to help on family members' computers anywhere. Connections between machines are end-to-end encrypted through a relay, requiring no VPN, port forwarding or router setup.
      1
      MIT
    • A
      license
      Not graded
      quality
      C
      maintenance
      Enables AI clients to securely control trusted devices and perform filesystem, terminal, process, and document operations through a self-hosted remote service.
      1,287,096 npm
      MIT
    • A
      license
      Not graded
      quality
      B
      maintenance
      Pre-alpha P2P remote-control app with a local stdio MCP bridge for paired computers. Users build from source; platform support and host-side approvals apply.
      2
      1
      AGPL 3.0
    • A
      license
      Not graded
      quality
      B
      maintenance
      It enables secure local monitoring and control of Windows PCs, including CPU/RAM/GPU metrics, process management, screenshots, clipboard, volume, power actions, and sandboxed file listing within allowed directories.
      MIT
    Try in Browser

    Glama MCP Gateway

    Add one secure layer between your agents and this server.

    Resources