What can you do with this server?

ReMCP lets an AI client read, write, and manage files, run shells, control the desktop, capture images, inspect the system, and edit documents on a paired computer over an outbound-only MCP connection. * Read files (read_file): read text/line-oriented files with offset/length paging, including negative offsets from the end. * Manage files (manage_files): search and glob files, read/write binaries in base64 chunks, hash files, list directories, get file info, write/edit/bulk-write, apply unified diffs, chmod/chown, block edits, line replacement, project-wide regex replace, diff files, move/copy/delete/trash paths, create/extract tar/tar.gz/zip archives, and manage search sessions. * Run terminal (run_terminal): start shell commands, read/wait/interact with output, force-terminate, and list sessions. * Control computer (control_computer): take accessibility/DOM/OCR snapshots, click/invoke/focus/set values/select/toggle/scroll on UI elements, multi-select/multi-edit, launch apps, and open or reveal paths. * View images (view_image): read existing image files and take desktop/window/monitor/region screenshots. * Manage system (manage_system): get system/runtime info and stats, list/kill processes, set runtime limits and telemetry, run network diagnostics, list installed apps, and inspect environment. * Manage documents (manage_documents): read PDF/DOCX/XLSX, edit spreadsheets and DOCX files, and merge/split/extract/inspect PDFs. All operations execute with the permissions of the account running the agent (SSH-like trust model), with no per-call approval prompt.

Which integrations are available for this server?

Offers a plugin for GitHub Copilot, allowing it to use ReMCP to interact with a paired computer's filesystem, processes, and system via the local runtime. Provides a plugin for ChatGPT and Codex, enabling them to use ReMCP's runtime to manage files, run processes, capture screenshots, and control a paired computer.

1. Click on "Deploy Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@ReMCP List the log files in my home directory" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

ReMCP

by getremcp

Overview Schema Source Related Servers Discussions Admin

JavaScript

Remote

ReMCP connects a computer you own or administer to ChatGPT & Codex, Cursor, Claude Code, Gemini CLI, Kiro, Cline, or another MCP client. The device agent makes an outbound connection only — no inbound port, no tunnel, no third-party desktop relay. This repository contains the public device client/runtime, portable Agent Plugin metadata, the Gemini CLI extension manifest, official MCP Registry metadata, and the host-specific OpenAI and Anthropic plugin packaging.

Packages

Package	What it is
`@remcp/remcp`	The device client: pairing, the outbound agent, the background service, and the usage-metrics switch.
`@remcp/runtime`	The first-party local runtime: 83 MCP tools for files, images, binary transfer, archives, screenshots, search, terminal/process work, native desktop UI, loopback browser CDP, diagnostics, lightweight documents, and narrowly scoped runtime preferences, with two direct dependencies.

Related MCP server: HostGate MCP

Install

Open ReMCP → Connect a machine. The page detects the computer's operating system and shows the correct one-command flow.

Windows PowerShell — no preinstalled Node.js, npm, npx, or winget required:

irm https://remcp.site/i | iex

ReMCP keeps its Windows runtime privately under %LOCALAPPDATA%\ReMCP; it does not install Node.js globally or add the private runtime directory to the system PATH.

macOS / Linux: Node.js 22.5 or newer provides the current npm/npx distribution path.

npx --yes @remcp/remcp@latest connect

The browser can also generate a one-time pairing command. Run that exact command on the computer you want to connect; it installs the runtime and registers the background service.

Pairing codes are generated in the authenticated workspace, expire automatically, and are single-use. Do not invent or reuse a code from documentation.

Commands

Command	Purpose
`remcp start`	Start the device agent when no managed background service is already running
`remcp status`	Show device, client/runtime versions, managed-agent state, update consistency and server reachability as JSON
`remcp doctor`	Status plus a real local-runtime handshake and filesystem diagnostics
`remcp install`	Install or repair the persistent user service
`remcp update`	Update the client and runtime, then restart the service
`remcp uninstall`	Stop and remove the user service
`remcp uninstall --purge`	Remove the service and the global packages
`remcp telemetry [status\|on\|off]`	Show or change usage metrics for the client and the runtime
`remcp godmode [status\|on\|off]`	Show or change this computer's local unrestricted mode
`remcp --version`	Print the installed client version

Plugins

For users, ReMCP is catalog-first:

Install from your AI host → sign in to ReMCP → use your paired computers.

You do not need to paste an MCP server URL, edit a manifest, clone this repository, or configure a local path just to use the published plugin.

Shareable install guides:

ChatGPT & Codex: https://remcp.site/install/chatgpt
Claude Code: https://remcp.site/install/claude

ChatGPT & Codex / OpenAI

ChatGPT and Codex share OpenAI's public plugin directory.

Open https://chatgpt.com/plugins.
Search for ReMCP and open the ReMCP plugin card when it is available.
Choose Install plugin.
If prompted, choose Connect and complete ReMCP OAuth.
In ChatGPT, use @ReMCP when you want to invoke it explicitly. In Codex, use Sources → Use plugins → ReMCP.

If ReMCP is not visible yet, the listing or rollout is not available to that account. There is no manual MCP endpoint an ordinary plugin user needs to configure while waiting.

Claude Code / Anthropic

ReMCP was submitted through Claude Platform on September 18, 2026 and currently shows Submitted and pending review.

After approval:

Open https://claude.com/plugins. In Claude or Claude Desktop, you can also use Customize → Plugins → + → Browse plugins.
Search for ReMCP and confirm it supports Claude Code.
Choose Install.
Complete ReMCP authorization if Claude asks you to connect.
Ask Claude Code to use ReMCP on a computer already paired to your account.

While the listing is under review, ordinary users do not need to add a marketplace, clone this repository, or paste an MCP endpoint. Developer and reviewer workflows live in the technical guide.

Start with Plugin overview →.

Cursor and the wider MCP ecosystem

ReMCP publishes host-native metadata for coding agents plus directory records for MCP discovery:

Host / directory	User path	Status
Cursor	Find ReMCP in Cursor Marketplace and install it.	published
Gemini CLI	Install from the Extension Gallery when indexed, or run `gemini extensions install https://github.com/antonbaider/remcp`.	gallery discovery enabled
GitHub Copilot CLI	Install from the `awesome-copilot` default marketplace after external-plugin review.	submitted
VS Code Agent Plugins	Browse `@agentPlugins` / Chat: Plugins after the same Awesome Copilot listing is accepted.	submitted
Kiro Powers	Import `https://github.com/antonbaider/remcp` from Add Custom Power → Import power from GitHub while the curated listing is reviewed.	submitted
Cline	Use the Cline MCP Marketplace after review; the current submission is tracked in `cline/marketplace` PR #125.	submitted
Smithery	Open https://smithery.ai/servers/antonbaider/remcp.	published
Glama	Open the ownership-verified connector at https://glama.ai/mcp/connectors/site.remcp/re-mcp.	verified / healthy
Awesome Remote MCP Servers	Open the community directory; ReMCP is listed under Developer Tools after PR #435 was merged.	listed
Official MCP Registry	Search for `io.github.getremcp/remcp`; GitHub resolves the project release URL `antonbaider/remcp` to the transferred `getremcp` repository, so this Registry namespace remains the active identity.	published

The same ReMCP OAuth account and paired computers sit behind every route. Marketplace and directory surfaces change discovery; they do not create separate ReMCP backends.

Distribution manifests, direct install commands, and review links are documented in PLUGINS.md → and DISTRIBUTION.md →.

Developer / reviewer internals

Host-specific manifests, MCP configuration, validation commands, submission artifacts, and local development workflows remain documented separately:

The OpenAI files and Claude files deliberately do not overwrite each other. Release checks fail if either host-specific contract drifts from the shared ReMCP version or production endpoint.

The local runtime

@remcp/runtime is a clean-room MCP server written for ReMCP. It is not a fork of, and shares no code with, DesktopCommanderMCP or any other MCP server.

83 granular device operations, 10 hosted production definitions. Current production advertises 8 device-facing façade tools plus 2 account/fleet tools, all model-visible. If custom widgets are explicitly re-enabled, discovery expands to 15 definitions by adding 5 app-only UI helpers. See the generated full tool reference for every current façade and its operation list.

Device runtime surface:

Area	Tools
Read	`read_file`, `read_files` (glob), `read_multiple_files`, `read_image`, `read_binary`, `list_directory`, `get_file_info`, `hash_file`, `diff_files`
Write / edit	`write_file`, `write_files` (bulk), `write_binary`, `apply_patch`, `set_permissions`, `edit_block`, `replace_lines`, `replace_in_files`
Organise	`create_directory` (bulk), `move_file`, `copy_file`, `copy_paths`, `move_paths`, `move_to_trash`, `create_archive`, `extract_archive`
Delete	`delete_path`, `delete_paths`
Transfer	`read_binary` and `write_binary` move any file in base64 chunks both ways; `create_archive` and `extract_archive` move whole trees
Screen	`take_screenshot` returns the desktop as an image
Search	`start_search`, `get_more_search_results`, `stop_search`, `list_searches`
Processes	`start_process`, `read_process_output`, `wait_for_process_output`, `interact_with_process`, `force_terminate`, `list_sessions`, `list_processes`, `kill_process`
Runtime	`get_system_info`, `get_runtime_info`, `get_runtime_stats`, `set_config_value`
Computer use	`computer_snapshot`, `computer_action`, `list_windows`, `window_action`, `launch_app`, `ui_snapshot`, `ui_find`, `ui_action`, `type_text`, `keyboard`, `pointer`, `drag_drop`, `scroll`, `wait_for_ui`, `clipboard`, `display_inventory`, `screenshot_region`, `open_path`, `reveal_path`, `notification`
Browser	`browser_tabs`, `browser_navigate`, `browser_snapshot`, `browser_find`, `browser_action`, `browser_wait`, `browser_evaluate`
Diagnostics	`service`, `event_log`, `network`, `installed_apps`, `environment`, `audio`, `power_action`, `record_screen`
Documents	`read_document`, `edit_spreadsheet`, `edit_document`, `pdf_action`

The hosted ReMCP endpoint currently advertises 10 model-visible tools with REMCP_CUSTOM_WIDGETS_ENABLED=false; no app-only render/save/refresh helpers or structuredContent.preview references are exposed. The compact surface routes to all 83 granular runtime operations, and 100 compatibility names remain callable for cached clients without inflating discovery for new models. If widgets are explicitly re-enabled later, the hosted catalog expands to 15 definitions and 105 compatibility names. Each online device returned by list_devices reports its live supported subset, and unavailable operations fail closed.

Tool selection for AI agents

ReMCP publishes selection-oriented descriptions and ships the same decision tree in its operator skill:

native Accessibility/UI Automation → browser DOM/CDP → OCR → coordinates

Start unfamiliar desktop work with computer_snapshot; use ui_snapshot/ui_find/ui_action for native apps.
For Chromium page content use browser_navigate action=new_tab when needed, then browser_snapshot/browser_find/browser_action/browser_wait instead of desktop coordinates.
Use type_text for normal Unicode text in native/focused controls, browser_action for Chromium page DOM text, and keyboard for shortcuts/navigation keys.
Use pointer only when semantic actions cannot express the task; prefer element ids for drag_drop. GNOME Wayland drag uses the consent-backed Remote Desktop portal rather than unreliable XTEST drag.
Use wait_for_ui / browser_wait instead of fixed sleeps.
Use screenshot_region for targeted visual proof and record_screen only for motion/timing.
Use structured document tools instead of automating Office when the request is about file content.

All 39 computer/browser/diagnostic/document tools declare closed top-level input schemas, parameter descriptions, structured output schemas, and MCP read-only/destructive/idempotent/open-world hints.

Why the tool list looks different from other computer-control servers. Security-sensitive configuration remains deliberately narrow, and everything else the alternatives can do has an equivalent here — usually more than one:

Not included	Why
Bundled browser/document rendering stacks	ReMCP supports lightweight DOCX/XLSX/PDF operations but deliberately uses OOXML and existing system PDF utilities instead of bundling Puppeteer, `sharp`, `exceljs`, or Chromium.
Broad configuration mutation	`set_config_value` can change only telemetry and context/output preferences. Access roots, blocked commands, command policy, shell, write limit and unrestricted mode stay local to the computer.
URL fetching in `read_file`	It is a server-side request forgery surface. The runtime reads your computer, not the internet.

What ReMCP adds beyond the usual set: image reads and screenshots that any MCP client can display, binary transfer in both directions, archive create/extract, wait_for_process_output instead of polling, line-range replacement, project-wide replace, unified diffs, checksums, trash instead of deletion, and host resource reporting.

Nothing is gated. There is no approval prompt, no "are you sure", and no mandatory dry run: a tool call executes with the full rights of the account running the agent — the same trust model as SSH. Writes replace by default and moves/copies replace the destination. The catastrophic-command guardrail defaults to block (a matching command is refused before it runs); an operator may choose warn or allow. Files are never written to a local history log, so tool arguments and output are not recorded there.

Unrestricted by design

No per-call approval contour. ReMCP does not add a confirmation dialog before each tool call. The local runtime's configured roots, command blocklist and command policy still apply, as do the operating-system permissions of the account running the agent. Within those boundaries, start_process can operate services, packages, databases, containers, sudo, git, and other local tools.
Full transfer in both directions. read_binary/write_binary move any file, create_archive and extract_archive move whole trees, and take_screenshot shows the desktop.
Optional hardening, explicit security boundaries. remcp godmode on lifts the roots, the blocklist and the command guardrail for one computer — and only a person at that computer can turn it on; no MCP tool accepts it. allowedRoots and blockedCommands are empty until an operator configures them. dangerousCommands defaults to block: a matching catastrophic command is refused before it runs; warn lets it run with an advisory note and allow silences even that. The runtime refuses to start — loudly — if runtime.json cannot be parsed, so configured safety boundaries are never silently dropped.
Crash-resistant. A bad shell, a closed stdin, or a 40 MB line cannot take the runtime down; the agent restarts it if it exits, so a device recovers instead of going quietly offline.
Outbound-only. Per-device revocable credential, hashed server-side, stored locally with restrictive permissions. Runtime metadata from a custom server requires an explicit --trust-runtime decision.
No local history. Tool arguments and outputs are never written to a log on your computer.

Usage metrics

Both the client and the runtime collect opt-out usage metrics: tool names, durations, outcomes, coarse error classes, session counts, and device health samples. They never include file paths, file contents, command strings, tool arguments, or tool output — the event schema is a whitelist, so those fields have nowhere to travel.

There is no telemetry endpoint and no third-party processor. The runtime emits MCP notifications to the agent, and the agent forwards them over the authenticated WebSocket it already holds to your ReMCP account. No install ping, no postinstall script, no remote feature flags, no A/B assignment.

remcp telemetry off      # one switch for the client and the runtime
remcp telemetry status

Development

npm install
npm run check
npm test

Both workspaces are plain ESM with no build step. The contract commands (--help, --version, --print-tools, --describe) work with no dependencies installed, so CI can diff the advertised tool surface against the published tarball.

License

MIT.

Available Tools

7 tools

control_computerControl computerA

Destructive

Inspect

Use this for semantic inspection or control of native desktop applications on this computer: windows, accessibility/UI elements, waits, displays, app launch, text/input, clipboard, open/reveal, notifications, or short screen recording. Snapshot/find/wait operations observe state; clicks, typing, window close, app launch, clipboard writes, and recording can change local application state. Prefer semantic targets before raw coordinates.

ParametersJSON Schema

Name	Required	Description	Default
`operation`	Yes	Concrete local runtime operation to execute in this domain.
`parameters`	No	Arguments for the selected operation; validated against that operation’s original closed schema.

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A4.2/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare destructiveHint=true and readOnlyHint=false. The description adds value by distinguishing observe-only operations from state-changing ones: 'Snapshot/find/wait operations observe state; clicks, typing, window close, app launch, clipboard writes, and recording can change local application state.' This is useful behavioral context beyond the annotations and is consistent with them.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Three sentences with no filler. The first sentence front-loads the tool's purpose and scope, the second adds critical behavioral nuance about which operations mutate state, and the third gives a targeting preference. Every sentence earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with this much schema complexity and a rich output schema, the description is sufficiently complete: it defines the domain, separates read vs. mutate operations, and offers a targeting heuristic. It does not enumerate all supported operations, but the schema's operation enum and parameter definitions carry that burden. Minor gaps like platform-specific caveats are left to the schema.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, and the schema provides extremely detailed descriptions for every parameter, including nested objects and operation-specific constraints. The description itself adds little parameter-level detail, but with full schema coverage the baseline of 3 is appropriate; it does not need to compensate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description names a specific verb and resource: 'semantic inspection or control of native desktop applications on this computer.' It lists concrete capability categories (windows, accessibility/UI elements, app launch, clipboard, recording) that clearly distinguish it from sibling file/terminal/read tools. An agent can tell this is the desktop-automation tool without opening the schema.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives clear context for when to use the tool: 'Use this for semantic inspection or control of native desktop applications on this computer.' It also provides an important operational guideline, 'Prefer semantic targets before raw coordinates.' It does not explicitly name alternatives or say when not to use it, but the domain boundary is clear enough against the sibling tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

manage_documentsManage documentsA

Destructive

Inspect

Use this for structured document content: read PDF/DOCX/XLSX, edit DOCX/XLSX directly, or merge, split, extract, or inspect PDFs. DOCX/XLSX edits can replace the input when no separate output is supplied, and PDF write operations create or replace their requested output; read_document itself is read-only. Use read_file for plain line-oriented text.

ParametersJSON Schema

Name	Required	Description	Default
`operation`	Yes	Concrete local runtime operation to execute in this domain.
`parameters`	No	Arguments for the selected operation; validated against that operation’s original closed schema.

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A4.7/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Beyond the annotations' destructiveHint=true, the description explains exactly when replacement happens: DOCX/XLSX edits replace the input when no output is supplied, and PDF write operations create or replace their requested output. It also isolates read_document as read-only, which is valuable context for a mixed read/write tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Three sentences with no filler: the main purpose is front-loaded, destructive behavior is stated compactly, and the sibling distinction is placed at the end. Every sentence earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a four-operation tool with rich conditional schemas and an output schema, the description is complete enough. It covers all operation families, warns about input replacement, notes the read-only exception, and routes plain-text cases to the correct sibling.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents all parameters in detail. The description adds operation-level context but no parameter-level nuance beyond what the schema provides, so the baseline of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a clear domain ('structured document content') and enumerates concrete operations: read PDF/DOCX/XLSX, edit DOCX/XLSX, and merge/split/extract/inspect PDFs. It also distinguishes itself from read_file, so an agent can tell sibling tools apart without opening their schemas.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

It explicitly prescribes this tool for structured document content and directs plain line-oriented text to read_file. The alternative is named and the selection condition is clear, satisfying the when-to-use vs. when-not-to-use criterion.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

manage_filesManage filesA

Destructive

Inspect

Use this when the task is about files, directories, archives, or filesystem search on this computer. Choose exactly one operation; parameters must contain only that operation’s arguments and are validated against its closed schema. Write, edit, move, permission, and delete operations can change or remove local data, while read and search operations leave files unchanged. Use read_file for one known text file.

ParametersJSON Schema

Name	Required	Description	Default
`operation`	Yes	Concrete local runtime operation to execute in this domain.
`parameters`	No	Arguments for the selected operation; validated against that operation’s original closed schema.

Output Schema

ParametersJSON Schema

Name	Required	Description
`text`	Yes	Human-readable result of the tool call.

TDQS

A4.5/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Beyond the annotations' destructiveHint=true, the description names which operation classes can change or remove local data and which leave files unchanged. It also discloses that parameters are validated against a closed per-operation schema. This materially improves the agent's understanding of a large, destructive-capable tool and does not contradict the annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Three sentences, no filler. The use condition is front-loaded, the per-operation constraint is stated clearly, and the read/write safety split and sibling routing are compressed into the remaining sentences. Every sentence earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite managing 29 sub-operations, the description gives the essential orientation: domain scope, one-operation rule, destructive vs read-only behavior, and a fallback to read_file. With such a rich input schema and an output schema present, the individual operation details are already covered structurally, so nothing critical is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the baseline is 3. The description mostly restates what the schema already says ('parameters must contain only that operation's arguments and are validated against its closed schema'), adding no new meaning to individual parameters. The rich schema carries the parameter semantics.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's scope: files, directories, archives, and filesystem search on this computer. It also distinguishes itself from the sibling read_file by routing single known text files there. The verb is somewhat generic ('manage'), but combined with the title and operation list it is clear enough.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly states when to use the tool ('task is about files, directories, archives, or filesystem search'), gives an explicit alternative ('Use read_file for one known text file'), and also separates read/search operations from write/edit/delete operations. An agent can reliably decide between this tool and the read_file sibling without opening the schema.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

manage_systemManage systemA

DestructiveIdempotent

Inspect

Use this for operating-system or ReMCP runtime state: system/runtime/process facts, runtime preferences, services, event logs, networking, installed apps, environment, audio, or explicit power actions. Fact, log, and inventory operations only observe state; process termination, preference/service/audio changes, restart, and shutdown can interrupt work or change the machine. Use run_terminal for general shell commands.

ParametersJSON Schema

Name	Required	Description	Default
`operation`	Yes	Concrete local runtime operation to execute in this domain.
`parameters`	No	Arguments for the selected operation; validated against that operation’s original closed schema.

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A4/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Even though annotations already provide destructiveHint and readOnlyHint, the description adds genuinely useful behavioral context by separating observe-only fact/log/inventory operations from operations that can interrupt work or change the machine. This tells an agent both what is safe and what consequences to expect beyond the boolean annotation hints.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is front-loaded and every sentence earns its place: domain, safety caveat, and routing to run_terminal. The first sentence is a lengthy category list and includes a few domains absent from the schema, so it is not perfectly tight, but overall it is appropriately concise for a broad umbrella tool.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the high complexity of nine conditional operations and nested parameters, the description is only a high-level umbrella and does not help an agent choose between similar operations such as get_system_info, get_runtime_info, and get_runtime_stats. The prose also claims support for services, event logs, audio, and power actions that are not represented in the operation enum, leaving a meaningful completeness gap despite the rich schema and output schema.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, and parameters like pid, limit, key, value, host, port, and action are already documented in the schema. The description contributes no parameter-level meaning, which meets the baseline for full schema coverage but does not elevate it.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description anchors the tool to a concrete domain (operating-system/ReMCP runtime state) and gives a meaningful category list: facts, processes, preferences, networking, installed apps, environment. It also distinguishes itself from run_terminal. However, it mentions services, event logs, audio, and power actions that do not appear in the operation enum, so the claimed scope is somewhat broader than the schema actually supports.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

It clearly states when to use this tool and explicitly routes general shell commands to run_terminal. It does not give exclusions for the other sibling tools or explain how to choose among the nine operations, but the main alternative is named and the intended context is clear.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

read_fileRead fileA

Read-onlyIdempotent

Inspect

Read a plain text or line-oriented file on this computer: source, config, Markdown, scripts or logs. Use read_document for PDF, DOCX, XLSX and other structured documents. Legacy .docx/.pdf extraction remains supported for compatibility. Use offset and length to page through large text files; a negative offset reads from the end.

ParametersJSON Schema

Name	Required	Description
`path`	Yes	Absolute path of the file to read. Relative paths resolve against the runtime working directory.
`length`	No	Maximum number of lines to return.
`offset`	No	Zero-based first line to read. Negative values read the last N lines.

Output Schema

ParametersJSON Schema

Name	Required	Description
`text`	Yes	Human-readable result of the tool call.

TDQS

A4.7/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already disclose read-only and idempotent behavior)Skip the description. The description adds real behavioral context: it limits the tool to text-like files, explains paging semantics, and discloses the legacy docx/pdf extraction behavior. This goes beyond annotation coverage without redundancy.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Three sentences, each with a distinct purpose: scope definition, alternative routing, and paging guidance. No fluff or repetition of schema fields. The phrasing is compact and front-loaded.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a single-file read tool, the description covers scope, exclusions, paging, and compatibility, while the output schema and read-only annotations cover the rest. An agent has enough information to invoke it correctly and to decide when another tool is better.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so the baseline is 3. The description adds value beyond the schema by explaining how offset and length should be used together to page through large files and clarifying the negative-offset behavior. This is meaningful, though the schema already documents each parameter.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific action (read), a specific resource type (plain text or line-oriented file), and concrete examples (source, config, Markdown, scripts, logs). Explicitly distinguishes from read_document for PDF/DOCX/XLSX, so an agent can select it among several sibling read tools.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Provides explicit routing guidance: use read_document for structured documentsainer and notes legacy .docx/.pdf support for compatibility. Also gives concrete usage advice for large files with offset/length paging and negative offsets.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

run_terminalRun terminal operationsA

Destructive

Inspect

Use this when the task needs a shell command or an existing ReMCP terminal session: start, read, wait, interact, stop, or list sessions. Choose exactly one operation; parameters are validated against that operation’s closed schema. Starting or interacting with commands can change local or external state, and force termination can lose unsaved process work; reading, waiting, and listing do not mutate the session.

ParametersJSON Schema

Name	Required	Description	Default
`operation`	Yes	Concrete local runtime operation to execute in this domain.
`parameters`	No	Arguments for the selected operation; validated against that operation’s original closed schema.

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A4.5/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Beyond the annotations, the description explicitly warns that starting or interacting with commands can change local or external state and that force termination can lose unsaved process work, while reading, waiting, and listing do not mutate the session. This clarifies the destructive/non-destructive split across operations and matches the annotation profile.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is three sentences, front-loaded with the trigger condition and operation list, followed by the crucial safety caveats. Every sentence contributes selection guidance or behavioral warning with no redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description covers when to use the tool, the need to select exactly one operation, validation behavior, and the mutation profile of each operation family. Since an output schema exists and the input schema fully documents each operation's parameters, no critical selection or invocation information is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, and the input schema already provides detailed descriptions for operation-specific parameters such as pid, offset, pattern, and timeout_ms. The description only adds a structural note about per-operation validation, not new meaning for individual parameters.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with a specific trigger condition ('when the task needs a shell command or an existing ReMCP terminal session') and enumerates the operation families: start, read, wait, interact, stop, and list sessions. This clearly distinguishes the terminal domain from sibling tools like manage_files or control_computer.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

It gives explicit context for when to use the tool and emphasizes that exactly one operation must be chosen, with parameters validated against that operation's schema. It does not explicitly name sibling alternatives or state when not to use the tool, so it stops short of a 5.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

view_imageView image or screenshotAInspect

Use this when the result must be pixels from this computer: read an existing image or capture the desktop, one window, monitor, or region. These operations return pixels without interacting with the visible UI. Use control_computer when semantic structure or an action is enough.

ParametersJSON Schema

Name	Required	Description	Default
`operation`	Yes	Concrete local runtime operation to execute in this domain.
`parameters`	No	Arguments for the selected operation; validated against that operation’s original closed schema.

Output Schema

ParametersJSON Schema

Name	Required	Description
`text`	Yes	Human-readable result of the tool call.

TDQS

A4/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description discloses a key behavioral trait: 'These operations return pixels without interacting with the visible UI', which is useful beyond the annotations. However, it claims capture of 'one window, monitor, or region' while the input schema for take_screenshot only exposes keep and directory parameters, leaving a behavioral promise the schema does not support. Annotations are all false and provide no additional coverage.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences, front-loaded with the key selection criterion ('when the result must be pixels'), and zero filler. The alternative and exclusion are stated efficiently in the second sentence.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The discriminated-union schema and output schema provide good structural coverage, and the description supplies overall context. However, the description overpromises window/monitor/region capture that is not reflected in the schema, creating a serious mismatch an agent must resolve before calling the tool correctly. This gap makes the definition not fully complete for its complexity.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the baseline should be 3cars, but the description actively adds misleading meaning by mentioning 'one window, monitor, or region' capture when no schema parameter supports selecting those targets. It does not clarify how the operation discriminates between read_image and take_screenshot beyond the fixed operation enum, and the unsupported target claims could cause an agent to pass invalid parameters.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific purpose: 'Use this when the result must be pixels from this computer', and enumerates the exact operations (read an existing image or capture desktop/window/monitor/region). It distinguishes itself from siblings by emphasizing pixels and the alternative control_computer for semantic structure or actions.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives explicit when-to-use guidance ('when the result must be pixels') and names the clear alternative ('Use control_computer when semantic structure or an action is enough'). It also adds context that these operations do not interact with the visible UI, helping an agent choose correctly.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

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

1 tool updatev0.2.112Sep 25, 2026

Changedmanage_documents3 fields changed

changedInput schema / allOf

Previous value: -[
-  {
-    "if": {
-      "properties": {
-        "operation": {
-          "const": "read_document"
-        }
-      },
-      "required": [
-        "operation"
-      ]
-    },
-    "then": {
-      "properties": {
-        "parameters": {
-          "additionalProperties": false,
-          "properties": {
-            "max_cells": {
-              "description": "Maximum number of spreadsheet cells to return.",
-              "type": "number"
-            },
-            "path": {
-              "description": "Document path.",
-              "type": "string"
-            },
-            "sheet": {
-              "description": "Worksheet name for XLSX.",
-              "type": "string"
-            }
-          },
-          "required": [
-            "path"
-          ],
-          "type": "object"
-        }
-      },
-      "required": [
-        "parameters"
-      ]
-    }
-  },
-  {
-    "if": {
-      "properties": {
-        "operation": {
-          "const": "pdf_action"
-        }
-      },
-      "required": [
-        "operation"
-      ]
-    },
-    "then": {
-      "properties": {
-        "parameters": {
-          "additionalProperties": false,
-          "allOf": [
-            {
-              "if": {
-                "properties": {
-                  "action": {
-                    "enum": [
-                      "annotations",
-                      "info",
-                      "split",
-                      "extract_pages"
-                    ]
-                  }
-                },
-                "required": [
-                  "action"
-                ]
-              },
-              "then": {
-                "required": [
-                  "path"
-                ]
-              }
-            },
-            {
-              "if": {
-                "properties": {
-                  "action": {
-                    "const": "merge"
-                  }
-                },
-                "required": [
-                  "action"
-                ]
-              },
-              "then": {
-                "required": [
-                  "paths",
-                  "output"
-                ]
-              }
-            },
-            {
-              "if": {
-                "properties": {
-                  "action": {
-                    "const": "extract_pages"
-                  }
-                },
-                "required": [
-                  "action"
-                ]
-              },
-              "then": {
-                "required": [
-                  "pages",
-                  "output"
-                ]
-              }
-            }
-          ],
-          "properties": {
-            "action": {
-              "description": "Operation to perform; choose the narrowest action that directly matches the requested outcome.",
-              "enum": [
-                "merge",
-                "split",
-                "extract_pages",
-                "annotations",
-                "info"
-              ],
-              "type": "string"
-            },
-            "output": {
-              "description": "Optional permitted output path; when omitted the tool may update the input according to its action.",
-              "type": "string"
-            },
-            "output_dir": {
-              "description": "Permitted directory for generated output files.",
-              "type": "string"
-            },
-            "pages": {
-              "description": "Page list/ranges such as 1-3,5.",
-              "type": "string"
-            },
-            "path": {
-              "description": "Permitted local filesystem path.",
-              "type": "string"
-            },
-            "paths": {
-              "description": "List of permitted local filesystem paths.",
-              "items": {
-                "type": "string"
-              },
-              "maxItems": 100,
-              "minItems": 2,
-              "type": "array"
-            },
-            "pattern": {
-              "description": "Output filename pattern where supported.",
-              "type": "string"
-            }
-          },
-          "required": [
-            "action"
-          ],
-          "type": "object"
-        }
-      },
-      "required": [
-        "parameters"
-      ]
-    }
-  }
-]New value: +[
+  {
+    "if": {
+      "properties": {
+        "operation": {
+          "const": "read_document"
+        }
+      },
+      "required": [
+        "operation"
+      ]
+    },
+    "then": {
+      "properties": {
+        "parameters": {
+          "additionalProperties": false,
+          "properties": {
+            "max_cells": {
+              "description": "Maximum number of spreadsheet cells to return.",
+              "type": "number"
+            },
+            "path": {
+              "description": "Document path.",
+              "type": "string"
+            },
+            "sheet": {
+              "description": "Worksheet name for XLSX.",
+              "type": "string"
+            }
+          },
+          "required": [
+            "path"
+          ],
+          "type": "object"
+        }
+      },
+      "required": [
+        "parameters"
+      ]
+    }
+  },
+  {
+    "if": {
+      "properties": {
+        "operation": {
+          "const": "edit_spreadsheet"
+        }
+      },
+      "required": [
+        "operation"
+      ]
+    },
+    "then": {
+      "properties": {
+        "parameters": {
+          "additionalProperties": false,
+          "properties": {
+            "create": {
+              "description": "Create a new XLSX at path. Fails if path already exists; do not combine with output.",
+              "type": "boolean"
+            },
+            "edits": {
+              "description": "Bounded list of spreadsheet edits; each item names a cell/range and the value(s) or formula to write.",
+              "items": {
+                "additionalProperties": false,
+                "properties": {
+                  "cell": {
+                    "description": "Single A1 cell reference.",
+                    "type": "string"
+                  },
+                  "formula": {
+                    "description": "Optional formula; for a range it is written to each expanded cell.",
+                    "type": "string"
+                  },
+                  "range": {
+                    "description": "Rectangular range such as A1:C3.",
+                    "type": "string"
+                  },
+                  "value": {
+                    "description": "Scalar value for one cell or to fill a range."
+                  },
+                  "values": {
+                    "description": "2D matrix matching the range dimensions.",
+                    "items": {
+                      "items": {},
+                      "type": "array"
+                    },
+                    "type": "array"
+                  }
+                },
+                "type": "object"
+              },
+              "maxItems": 500,
+              "type": "array"
+            },
+            "output": {
+              "description": "Optional output .xlsx when editing an existing workbook; defaults to replacing input.",
+              "type": "string"
+            },
+            "path": {
+              "description": "Existing .xlsx path, or the new workbook destination when create=true.",
+              "type": "string"
+            },
+            "sheet": {
+              "description": "Worksheet name. For create=true, defaults to Sheet1 and becomes the new workbook sheet name.",
+              "type": "string"
+            }
+          },
+          "required": [
+            "path",
+            "edits"
+          ],
+          "type": "object"
+        }
+      },
+      "required": [
+        "parameters"
+      ]
+    }
+  },
+  {
+    "if": {
+      "properties": {
+        "operation": {
+          "const": "edit_document"
+        }
+      },
+      "required": [
+        "operation"
+      ]
+    },
+    "then": {
+      "properties": {
+        "parameters": {
+          "additionalProperties": false,
+          "properties": {
+            "create": {
+              "description": "Create a new DOCX at path. Fails if path already exists; do not combine with output.",
+              "type": "boolean"
+            },
+            "operations": {
+              "description": "Bounded list of structured document operations executed in order.",
+              "items": {
+                "additionalProperties": false,
+                "properties": {
+                  "action": {
+                    "description": "Operation to perform; choose the narrowest action that directly matches the requested outcome.",
+                    "enum": [
+                      "replace",
+                      "append_paragraph",
+                      "prepend_paragraph",
+                      "insert_paragraph_before",
+                      "insert_paragraph_after",
+                      "delete_paragraph"
+                    ],
+                    "type": "string"
+                  },
+                  "all": {
+                    "description": "Apply to all matching paragraphs; default true.",
+                    "type": "boolean"
+                  },
+                  "replacement": {
+                    "description": "Replacement text for matching document content.",
+                    "type": "string"
+                  },
+                  "search": {
+                    "description": "Paragraph text substring for replace/insert/delete operations.",
+                    "type": "string"
+                  },
+                  "text": {
+                    "description": "Paragraph text to append/prepend/insert.",
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "action"
+                ],
+                "type": "object"
+              },
+              "maxItems": 100,
+              "type": "array"
+            },
+            "output": {
+              "description": "Optional output .docx path when editing an existing document.",
+              "type": "string"
+            },
+            "path": {
+              "description": "Existing .docx path, or the new document destination when create=true.",
+              "type": "string"
+            }
+          },
+          "required": [
+            "path",
+            "operations"
+          ],
+          "type": "object"
+        }
+      },
+      "required": [
+        "parameters"
+      ]
+    }
+  },
+  {
+    "if": {
+      "properties": {
+        "operation": {
+          "const": "pdf_action"
+        }
+      },
+      "required": [
+        "operation"
+      ]
+    },
+    "then": {
+      "properties": {
+        "parameters": {
+          "additionalProperties": false,
+          "allOf": [
+            {
+              "if": {
+                "properties": {
+                  "action": {
+                    "enum": [
+                      "annotations",
+                      "info",
+                      "split",
+                      "extract_pages"
+                    ]
+                  }
+                },
+                "required": [
+                  "action"
+                ]
+              },
+              "then": {
+                "required": [
+                  "path"
+                ]
+              }
+            },
+            {
+              "if": {
+                "properties": {
+                  "action": {
+                    "const": "merge"
+                  }
+                },
+                "required": [
+                  "action"
+                ]
+              },
+              "then": {
+                "required": [
+                  "paths",
+                  "output"
+                ]
+              }
+            },
+            {
+              "if": {
+                "properties": {
+                  "action": {
+                    "const": "extract_pages"
+                  }
+                },
+                "required": [
+                  "action"
+                ]
+              },
+              "then": {
+                "required": [
+                  "pages",
+                  "output"
+                ]
+              }
+            }
+          ],
+          "properties": {
+            "action": {
+              "description": "Operation to perform; choose the narrowest action that directly matches the requested outcome.",
+              "enum": [
+                "merge",
+                "split",
+                "extract_pages",
+                "annotations",
+                "info"
+              ],
+              "type": "string"
+            },
+            "output": {
+              "description": "Optional permitted output path; when omitted the tool may update the input according to its action.",
+              "type": "string"
+            },
+            "output_dir": {
+              "description": "Permitted directory for generated output files.",
+              "type": "string"
+            },
+            "pages": {
+              "description": "Page list/ranges such as 1-3,5.",
+              "type": "string"
+            },
+            "path": {
+              "description": "Permitted local filesystem path.",
+              "type": "string"
+            },
+            "paths": {
+              "description": "List of permitted local filesystem paths.",
+              "items": {
+                "type": "string"
+              },
+              "maxItems": 100,
+              "minItems": 2,
+              "type": "array"
+            },
+            "pattern": {
+              "description": "Output filename pattern where supported.",
+              "type": "string"
+            }
+          },
+          "required": [
+            "action"
+          ],
+          "type": "object"
+        }
+      },
+      "required": [
+        "parameters"
+      ]
+    }
+  }
+]

changedInput schema / properties / operation / enum

Previous value: -[
-  "read_document",
-  "pdf_action"
-]New value: +[
+  "read_document",
+  "edit_spreadsheet",
+  "edit_document",
+  "pdf_action"
+]

changedOutput schema / oneOf

Previous value: -[
-  {
-    "additionalProperties": true,
-    "description": "Read document structured result for read_document. Stable fields are declared explicitly; platform-specific fields may be added. Large results may return truncated/bytes/preview instead of the full payload.",
-    "properties": {
-      "bytes": {
-        "description": "Serialized structured-result size when truncation metadata is returned.",
-        "type": "number"
-      },
-      "cells": {
-        "items": {},
-        "type": "array"
-      },
-      "data": {},
-      "path": {
-        "type": "string"
-      },
-      "preview": {
-        "description": "Bounded JSON preview when the full structured mirror is too large.",
-        "type": "string"
-      },
-      "rows": {
-        "items": {},
-        "type": "array"
-      },
-      "sheet": {
-        "type": "string"
-      },
-      "sheets": {
-        "items": {
-          "additionalProperties": true,
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "text": {
-        "type": "string"
-      },
-      "truncated": {
-        "description": "True when the structured mirror was bounded because the result was large.",
-        "type": "boolean"
-      }
-    },
-    "type": "object"
-  },
-  {
-    "additionalProperties": true,
-    "description": "PDF action structured result for pdf_action. Stable fields are declared explicitly; platform-specific fields may be added. Large results may return truncated/bytes/preview instead of the full payload.",
-    "properties": {
-      "action": {
-        "type": "string"
-      },
-      "annotation_count": {
-        "description": "Number of PDF annotations found by the info action.",
-        "type": "number"
-      },
-      "annotations": {
-        "items": {
-          "additionalProperties": true,
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "bytes": {
-        "description": "Serialized structured-result size when truncation metadata is returned.",
-        "type": "number"
-      },
-      "data": {
-        "description": "Array/scalar payload wrapper used when the natural result is not an object."
-      },
-      "files": {
-        "items": {
-          "type": "string"
-        },
-        "type": "array"
-      },
-      "inputs": {
-        "type": "number"
-      },
-      "output": {
-        "type": "string"
-      },
-      "output_dir": {
-        "type": "string"
-      },
-      "pages": {
-        "type": "string"
-      },
-      "path": {
-        "type": "string"
-      },
-      "preview": {
-        "description": "Bounded JSON preview when the full structured mirror is too large.",
-        "type": "string"
-      },
-      "source": {
-        "type": "string"
-      },
-      "text": {
-        "description": "Human-readable structured mirror for text-only results.",
-        "type": "string"
-      },
-      "truncated": {
-        "description": "True when the structured mirror was bounded because the result was large.",
-        "type": "boolean"
-      }
-    },
-    "type": "object"
-  }
-]New value: +[
+  {
+    "additionalProperties": true,
+    "description": "Read document structured result for read_document. Stable fields are declared explicitly; platform-specific fields may be added. Large results may return truncated/bytes/preview instead of the full payload.",
+    "properties": {
+      "bytes": {
+        "description": "Serialized structured-result size when truncation metadata is returned.",
+        "type": "number"
+      },
+      "cells": {
+        "items": {},
+        "type": "array"
+      },
+      "data": {},
+      "path": {
+        "type": "string"
+      },
+      "preview": {
+        "description": "Bounded JSON preview when the full structured mirror is too large.",
+        "type": "string"
+      },
+      "rows": {
+        "items": {},
+        "type": "array"
+      },
+      "sheet": {
+        "type": "string"
+      },
+      "sheets": {
+        "items": {
+          "additionalProperties": true,
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "text": {
+        "type": "string"
+      },
+      "truncated": {
+        "description": "True when the structured mirror was bounded because the result was large.",
+        "type": "boolean"
+      }
+    },
+    "type": "object"
+  },
+  {
+    "additionalProperties": true,
+    "description": "Edit spreadsheet structured result for edit_spreadsheet. Stable fields are declared explicitly; platform-specific fields may be added. Large results may return truncated/bytes/preview instead of the full payload.",
+    "properties": {
+      "bytes": {
+        "description": "Serialized structured-result size when truncation metadata is returned.",
+        "type": "number"
+      },
+      "created": {
+        "type": "boolean"
+      },
+      "data": {
+        "description": "Array/scalar payload wrapper used when the natural result is not an object."
+      },
+      "edited_cells": {
+        "type": "number"
+      },
+      "path": {
+        "type": "string"
+      },
+      "preview": {
+        "description": "Bounded JSON preview when the full structured mirror is too large.",
+        "type": "string"
+      },
+      "sheet": {
+        "type": "string"
+      },
+      "text": {
+        "description": "Human-readable structured mirror for text-only results.",
+        "type": "string"
+      },
+      "truncated": {
+        "description": "True when the structured mirror was bounded because the result was large.",
+        "type": "boolean"
+      }
+    },
+    "type": "object"
+  },
+  {
+    "additionalProperties": true,
+    "description": "Edit DOCX document structured result for edit_document. Stable fields are declared explicitly; platform-specific fields may be added. Large results may return truncated/bytes/preview instead of the full payload.",
+    "properties": {
+      "bytes": {
+        "description": "Serialized structured-result size when truncation metadata is returned.",
+        "type": "number"
+      },
+      "changes": {
+        "type": "number"
+      },
+      "created": {
+        "type": "boolean"
+      },
+      "data": {
+        "description": "Array/scalar payload wrapper used when the natural result is not an object."
+      },
+      "operations": {
+        "type": "number"
+      },
+      "path": {
+        "type": "string"
+      },
+      "preview": {
+        "description": "Bounded JSON preview when the full structured mirror is too large.",
+        "type": "string"
+      },
+      "text": {
+        "description": "Human-readable structured mirror for text-only results.",
+        "type": "string"
+      },
+      "truncated": {
+        "description": "True when the structured mirror was bounded because the result was large.",
+        "type": "boolean"
+      }
+    },
+    "type": "object"
+  },
+  {
+    "additionalProperties": true,
+    "description": "PDF action structured result for pdf_action. Stable fields are declared explicitly; platform-specific fields may be added. Large results may return truncated/bytes/preview instead of the full payload.",
+    "properties": {
+      "action": {
+        "type": "string"
+      },
+      "annotation_count": {
+        "description": "Number of PDF annotations found by the info action.",
+        "type": "number"
+      },
+      "annotations": {
+        "items": {
+          "additionalProperties": true,
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "bytes": {
+        "description": "Serialized structured-result size when truncation metadata is returned.",
+        "type": "number"
+      },
+      "data": {
+        "description": "Array/scalar payload wrapper used when the natural result is not an object."
+      },
+      "files": {
+        "items": {
+          "type": "string"
+        },
+        "type": "array"
+      },
+      "inputs": {
+        "type": "number"
+      },
+      "output": {
+        "type": "string"
+      },
+      "output_dir": {
+        "type": "string"
+      },
+      "pages": {
+        "type": "string"
+      },
+      "path": {
+        "type": "string"
+      },
+      "preview": {
+        "description": "Bounded JSON preview when the full structured mirror is too large.",
+        "type": "string"
+      },
+      "source": {
+        "type": "string"
+      },
+      "text": {
+        "description": "Human-readable structured mirror for text-only results.",
+        "type": "string"
+      },
+      "truncated": {
+        "description": "True when the structured mirror was bounded because the result was large.",
+        "type": "boolean"
+      }
+    },
+    "type": "object"
+  }
+]

1 tool updatev0.2.106Sep 23, 2026

Changedmanage_documents1 field changed

changedOutput schema / oneOf

Previous value: -[
-  {
-    "additionalProperties": true,
-    "description": "Read document structured result for read_document. Stable fields are declared explicitly; platform-specific fields may be added. Large results may return truncated/bytes/preview instead of the full payload.",
-    "properties": {
-      "bytes": {
-        "description": "Serialized structured-result size when truncation metadata is returned.",
-        "type": "number"
-      },
-      "cells": {
-        "items": {},
-        "type": "array"
-      },
-      "data": {},
-      "path": {
-        "type": "string"
-      },
-      "preview": {
-        "description": "Bounded JSON preview when the full structured mirror is too large.",
-        "type": "string"
-      },
-      "rows": {
-        "items": {},
-        "type": "array"
-      },
-      "sheet": {
-        "type": "string"
-      },
-      "sheets": {
-        "items": {
-          "additionalProperties": true,
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "text": {
-        "type": "string"
-      },
-      "truncated": {
-        "description": "True when the structured mirror was bounded because the result was large.",
-        "type": "boolean"
-      }
-    },
-    "type": "object"
-  },
-  {
-    "additionalProperties": true,
-    "description": "PDF action structured result for pdf_action. Stable fields are declared explicitly; platform-specific fields may be added. Large results may return truncated/bytes/preview instead of the full payload.",
-    "properties": {
-      "action": {
-        "type": "string"
-      },
-      "annotations": {
-        "items": {
-          "additionalProperties": true,
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "bytes": {
-        "description": "Serialized structured-result size when truncation metadata is returned.",
-        "type": "number"
-      },
-      "data": {
-        "description": "Array/scalar payload wrapper used when the natural result is not an object."
-      },
-      "files": {
-        "items": {
-          "type": "string"
-        },
-        "type": "array"
-      },
-      "inputs": {
-        "type": "number"
-      },
-      "output": {
-        "type": "string"
-      },
-      "output_dir": {
-        "type": "string"
-      },
-      "pages": {
-        "type": "string"
-      },
-      "path": {
-        "type": "string"
-      },
-      "preview": {
-        "description": "Bounded JSON preview when the full structured mirror is too large.",
-        "type": "string"
-      },
-      "source": {
-        "type": "string"
-      },
-      "text": {
-        "description": "Human-readable structured mirror for text-only results.",
-        "type": "string"
-      },
-      "truncated": {
-        "description": "True when the structured mirror was bounded because the result was large.",
-        "type": "boolean"
-      }
-    },
-    "type": "object"
-  }
-]New value: +[
+  {
+    "additionalProperties": true,
+    "description": "Read document structured result for read_document. Stable fields are declared explicitly; platform-specific fields may be added. Large results may return truncated/bytes/preview instead of the full payload.",
+    "properties": {
+      "bytes": {
+        "description": "Serialized structured-result size when truncation metadata is returned.",
+        "type": "number"
+      },
+      "cells": {
+        "items": {},
+        "type": "array"
+      },
+      "data": {},
+      "path": {
+        "type": "string"
+      },
+      "preview": {
+        "description": "Bounded JSON preview when the full structured mirror is too large.",
+        "type": "string"
+      },
+      "rows": {
+        "items": {},
+        "type": "array"
+      },
+      "sheet": {
+        "type": "string"
+      },
+      "sheets": {
+        "items": {
+          "additionalProperties": true,
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "text": {
+        "type": "string"
+      },
+      "truncated": {
+        "description": "True when the structured mirror was bounded because the result was large.",
+        "type": "boolean"
+      }
+    },
+    "type": "object"
+  },
+  {
+    "additionalProperties": true,
+    "description": "PDF action structured result for pdf_action. Stable fields are declared explicitly; platform-specific fields may be added. Large results may return truncated/bytes/preview instead of the full payload.",
+    "properties": {
+      "action": {
+        "type": "string"
+      },
+      "annotation_count": {
+        "description": "Number of PDF annotations found by the info action.",
+        "type": "number"
+      },
+      "annotations": {
+        "items": {
+          "additionalProperties": true,
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "bytes": {
+        "description": "Serialized structured-result size when truncation metadata is returned.",
+        "type": "number"
+      },
+      "data": {
+        "description": "Array/scalar payload wrapper used when the natural result is not an object."
+      },
+      "files": {
+        "items": {
+          "type": "string"
+        },
+        "type": "array"
+      },
+      "inputs": {
+        "type": "number"
+      },
+      "output": {
+        "type": "string"
+      },
+      "output_dir": {
+        "type": "string"
+      },
+      "pages": {
+        "type": "string"
+      },
+      "path": {
+        "type": "string"
+      },
+      "preview": {
+        "description": "Bounded JSON preview when the full structured mirror is too large.",
+        "type": "string"
+      },
+      "source": {
+        "type": "string"
+      },
+      "text": {
+        "description": "Human-readable structured mirror for text-only results.",
+        "type": "string"
+      },
+      "truncated": {
+        "description": "True when the structured mirror was bounded because the result was large.",
+        "type": "boolean"
+      }
+    },
+    "type": "object"
+  }
+]

59 tool updatesv0.2.88Sep 21, 2026
- Removedapply_patch
- Removedcomputer_action
- Removedcomputer_snapshot
- Addedcontrol_computer
- Removedcopy_file
- Removedcopy_paths
- Removedcreate_archive
- Removedcreate_directory
- Removeddelete_path
- Removeddelete_paths
- Removeddiff_files
- Removededit_block
- Removedenvironment
- Removedextract_archive
- Removedforce_terminate
- Removedget_file_info
- Removedget_more_search_results
- Removedget_runtime_info
- Removedget_runtime_stats
- Removedget_system_info
- Removedhash_file
- Removedinstalled_apps
- Removedinteract_with_process
- Removedkill_process
- Removedlaunch_app
- Removedlist_directory
- Removedlist_processes
- Removedlist_searches
- Removedlist_sessions
- Addedmanage_documents
- Addedmanage_files
- Addedmanage_system
- Removedmove_file
- Removedmove_paths
- Removedmove_to_trash
- Removednetwork
- Removedopen_path
- Removedpdf_action
- Removedread_binary
- Removedread_document
- Removedread_files
- Removedread_image
- Removedread_multiple_files
- Removedread_process_output
- Removedreplace_in_files
- Removedreplace_lines
- Removedreveal_path
- Addedrun_terminal
- Removedset_config_value
- Removedset_permissions
- Removedstart_process
- Removedstart_search
- Removedstop_search
- Removedtake_screenshot
- Addedview_image
- Removedwait_for_process_output
- Removedwrite_binary
- Removedwrite_file
- Removedwrite_files
54 tool updatesv0.1.0Sep 21, 2026
- First observedapply_patch
- First observedcomputer_action
- First observedcomputer_snapshot
- First observedcopy_file
- First observedcopy_paths
- First observedcreate_archive
- First observedcreate_directory
- First observeddelete_path
- First observeddelete_paths
- First observeddiff_files
- First observededit_block
- First observedenvironment
- First observedextract_archive
- First observedforce_terminate
- First observedget_file_info
- First observedget_more_search_results
- First observedget_runtime_info
- First observedget_runtime_stats
- First observedget_system_info
- First observedhash_file
- First observedinstalled_apps
- First observedinteract_with_process
- First observedkill_process
- First observedlaunch_app
- First observedlist_directory
- First observedlist_processes
- First observedlist_searches
- First observedlist_sessions
- First observedmove_file
- First observedmove_paths
- First observedmove_to_trash
- First observednetwork
- First observedopen_path
- First observedpdf_action
- First observedread_binary
- First observedread_document
- First observedread_file
- First observedread_files
- First observedread_image
- First observedread_multiple_files
- First observedread_process_output
- First observedreplace_in_files
- First observedreplace_lines
- First observedreveal_path
- First observedset_config_value
- First observedset_permissions
- First observedstart_process
- First observedstart_search
- First observedstop_search
- First observedtake_screenshot
- First observedwait_for_process_output
- First observedwrite_binary
- First observedwrite_file
- First observedwrite_files

Deploy Server

One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

TDQS

A4.4/5.0

Scored 2026-09-25 21:00 across 7 tools

Disambiguation5/5

Each tool has a clearly distinct purpose: UI control, document handling, file management, system state, plain text reading, terminal sessions, and image capture. Even overlapping areas (read_file vs manage_documents) are explicitly separated by file type, and control_computer vs view_image are differentiated by semantic vs pixel access.

Naming Consistency5/5

All tool names follow a consistent verb_noun pattern in snake_case (control_computer, manage_documents, read_file, run_terminal, view_image). The verbs are descriptive and the nouns clearly indicate the target domain, making the pattern predictable and easy to infer.

Tool Count5/5

Seven tools is well within the ideal range for a computer automation server. Each tool covers a major functional area (UI, documents, files, system, text, terminal, images) without redundancy or bloat, and the count feels appropriately scoped for the server's broad but coherent purpose.

Completeness5/5

The tool surface covers the core lifecycle of computer interaction: reading and writing files, managing documents, controlling the UI, running commands, viewing pixels, and inspecting system state. There are no obvious dead ends—each tool has both read and write/action operations, and the set collectively addresses the full range of typical automation tasks.

Maintenance

ActivityMaintained

ResponsivenessNo issues

Resources

Need Help?

Related Servers

Related MCP Connectors

AurelianFlo A
com.aurelianflo
Remote MCP server for OFAC screening, EDD memos, exposure forecasts, queues, and reports.
Legal & Compliance Finance
112
mcp
com.localtonet
Secure tunneling, reverse proxy and remote access for local applications.
Networking & Infrastructure Developer Tools
2
docs-mcp A
ac.tandem
Remote MCP server for Tandem docs, install guides, SDKs, workflows, and agent setup help.
Documentation Access Developer Tools
287
termalin-web A
in.termal
Run commands and read/write files on your servers over Termalin's keyless tunnels (hosted MCP).
Shell Access File Systems
81

Related MCP Servers

cloud-to-local
File Systems Command Line OS Automation
plhys
A
license
Not graded
quality
A
maintenance
Enables cloud agents to securely operate local machine resources (files, commands, screenshots) via standard MCP protocol.
Updated 2 months ago (2026-07-20 08:37 UTC)
MIT
HostGate MCP
Shell Access Security Autonomous Agents
Taffy-1
A
license
Not graded
quality
B
maintenance
Enables an MCP client to safely access selected local files and trusted executables with policy control, audit, and rollback via a Windows control center.
Updated 4 days ago (2026-09-27 02:22 UTC)
Apache 2.0
Portal
Shell Access File Systems
s3hq4y
A
license
Not graded
quality
A
maintenance
Enables MCP clients to connect to a local workspace over a public tunnel and lets them run shell commands and transfer files bidirectionally.
Updated 14 days ago (2026-09-16 08:24 UTC)
262 npm
21
GPL 3.0
MCP SSH Server
Command Line Shell Access File Systems
liliangshan
A
license
A
quality
C
maintenance
Enables remote command execution and SFTP file upload or download from any MCP client without a local SSH client, SCP, or PuTTY installed. Supports password or private key authentication with SHA256 host fingerprint verification, timeouts, output limits, and multiple configured server instances.
Updated 18 days ago (2026-09-12 10:11 UTC)
5
13 npm
MIT