Connects AI clients to Windows, macOS, and Linux computers to execute authorized commands, manage files, and interact with cloud applications.
Also known as Remote-Arc/remote-arc, remotelink
- Stars
- 1
- Tools
- —
- Downloads, 30 days
- —
- Latest version
- —
- Last commit
- Nov 15, 2026
- License
- —
What is Remote Arc MCP?
Remote Arc connects AI clients to Windows, macOS, and Linux computers to execute authorized commands, manage files, and interact with cloud applications.
Summary generated from the project's README
About Remote Arc MCP server
Remote Arc provides infrastructure that allows AI agents to perform actual work across cloud applications and physical hardware. By connecting to compatible clients like Claude, ChatGPT, Cursor, or other MCP-compatible tools, it enables models to execute authorized commands, manage files, and interact with software. The system works by pairing computers running Windows, macOS, or Linux, which connect outward to the service without requiring a VPN or public inbound ports.
Users can choose between the hosted Arc workspace for managing tasks and routines or the Connect method to bring these capabilities into their existing AI environments. The platform manages the necessary context, permissions, and persistent history so that model decisions result in inspectable outcomes. While the AI handles reasoning, Remote Arc manages the execution layer, providing typed operation contracts and cost accounting. Different subscription tiers offer varying levels of computer pairings and monthly allowances for calls and file transfers.
What you can do with it
- 1Execute local computer commandsA developer can instruct an AI client to run specific terminal commands or manage files on a paired Windows, macOS, or Linux machine.
- 2Automate cloud application workflowsYou can authorize cloud accounts to allow an AI agent to perform operations within your web-based applications.
- 3Schedule recurring maintenance tasksAn AI can be assigned a routine such as disk-space recovery using specific skills that run on a set schedule.
- 4Perform browser-based web tasksThe system can execute site-scoped work within a browser using the Chrome Companion or a dedicated task browser.
Written from the project's README. Every use case is checked against a quote from it.
How to install Remote Arc MCP
Formats verified 10 Nov 2026Add to CursorAdd to GooseInstall Remote Arc MCP in Claude Code
$ claude mcp add remote-arc -- npx -y remotelinkInstall Remote Arc MCP in Cursor
~/.cursor/mcp.json
{
"mcpServers": {
"remote-arc": {
"command": "npx",
"args": [
"-y",
"remotelink"
]
}
}
}Install Remote Arc MCP in VS Code
.vscode/mcp.json
{
"servers": {
"remote-arc": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"remotelink"
]
}
}
}Install Remote Arc MCP in VS Code CLI
$ code --add-mcp '{"name":"remote-arc","type":"stdio","command":"npx","args":["-y","remotelink"]}'Install Remote Arc MCP in Claude Desktop
claude_desktop_config.json
{
"mcpServers": {
"remote-arc": {
"command": "npx",
"args": [
"-y",
"remotelink"
]
}
}
}Install Remote Arc MCP in Codex
$ codex mcp add remote-arc -- npx -y remotelinkInstall Remote Arc MCP in Codex config.toml
~/.codex/config.toml
[mcp_servers.remote-arc] command = "npx" args = ["-y", "remotelink"]
Install Remote Arc MCP in Gemini CLI
$ gemini mcp add -s user remote-arc npx -- -y remotelinkInstall Remote Arc MCP in Gemini settings.json
~/.gemini/settings.json
{
"mcpServers": {
"remote-arc": {
"command": "npx",
"args": [
"-y",
"remotelink"
]
}
}
}Configuration
REMOTEARC_MANUAL_PROD_DEPLOY
| Name | Description | |
|---|---|---|
| REMOTEARC_MANUAL_PROD_DEPLOY | — |
Automated checks
Ran Nov 14, 2026Full report →Passed our automated checks. That is not a security audit: read the code and give the server the narrowest access it needs. How checks work · What to fix for more points
- Source repository linked and reachableremote-arc/remote-arc is public and reachablegithub.com/remote-arc/remote-arc ↗Pass
- Package names this repository as its sourceremotelink names remote-arc/remote-arc as sourcenpmjs.com/package/remotelink ↗Pass
- Build provenance (Sigstore attestation)Sigstore attestation for remotelinknpmjs.com/package/remotelink/v/0.7.2#provenance ↗Pass
- Open source license (OSI)No licenseFinding
- Commit or release in the last yearLast commit or release 2026-11-14github.com/remote-arc/remote-arc ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNo popular package one edit away from remotelinkPass
- No critical advisory in the package or its dependenciesNot checked
- No hidden instructions to the model0 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNot checked
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubRemote Arc
Agent infrastructure for real work across your apps and computers.
Arc is your hosted AI agent. Connect brings the same authorized Apps and device execution to the AI client you already use. Remote Arc manages the context, permissions, persistent work, device placement and usage around model decisions so work can proceed from a request to an inspectable result.
Website · Open Arc · User guide · Architecture · Security
Source available for transparency and security review under a proprietary license. Not open-source licensed.
Latest validated statement coverage; target ≥90%. Apps and Relay overlap TS/TSX. Scope, other metrics and source.
Two ways to work
| Product | Start here | What it does |
|---|---|---|
| Arc | Hosted workspace | Chat with a personal agent, use connected Apps/computers, reuse Skills, and create one-off Tasks or recurring routines. |
| Connect | Connect your AI | Use authorized cloud accounts, paired devices and your browser from compatible ChatGPT, Claude, Codex, Cursor or other MCP clients. |
Arc keeps a delegated responsibility together: its sources, instructions, conversation and run history, with fresh bounded judgment when scheduled and checks against actual results. Start with a daily work brief, project check-in, delivery verification or change follow-up. The use-case catalog also keeps Arc and Connect paths for all 15 concrete workflows.
Every plan includes every Connect tool. Free has monthly Connect call and file-transfer allowances and up to 2 computers. Pro, formerly Connect Unlimited, removes the monthly Connect call cap. Pro and Max include the computers, Arc-hosted AI and monthly Credits shown at checkout and in billing settings. Existing subscriptions retain their purchased terms until explicitly changed. Every account can activate a one-time 14-day Arc trial. Users never supply a model API key. Current prices and allowances are on the pricing page; third-party App charges are separate. Preview environments use simulated data.
From a goal to a result
- Connect what the work needs. Authorize a cloud account in Apps, or pair a computer for local files, commands and installed software. Cloud Apps do not require a local computer.
- Describe the outcome. Ask for an inbox summary, an issue with a returned link, or a deployment check. Type
@in Arc Chat to reuse a selected cloud/imported skill, then describe the desired result. - Execute within current permissions. Models interpret, plan, choose tools and summarize. Arc supplies bounded context, typed operation contracts, authorization, dispatch, persisted observations and cost accounting.
- Inspect the result. A connection check or successful individual tool call is not the whole goal. Chat presents the final answer; Activity provides execution details. Missing permissions, engines, devices or budgets must be reported as blockers.
- Keep ongoing work. Ask Arc to save a one-off Task or a routine with accounts, timing and timezone. Runs are persisted and scheduled; failed or uncertain recurring work pauses for inspection.
Earn trust through execution
- Evidence: return observed content, an acknowledged resource or a concrete blocker; a tool call alone is not task completion.
- Boundaries: current account permissions and local policy apply to each action; skill text and messages cannot grant more authority.
- Continuity: retain useful context and results; stop rather than blindly repeat an uncertain external write.
- Control: users can stop work, revoke connections, inspect Activity and manage memory; budgets bound hosted execution.
The run status records whether execution ended. Verify the answer and its evidence to assess the goal. The technical reference describes current tests and limits instead of promising that an agent can complete any possible task.
Platform capabilities
- Connected Apps: account-owned, typed provider operations with live scope checks, stable request identities and recorded outcomes.
- Tasks and routines: saved goals, schedules, leases, bounded hosted runs and result history. Connect also supports deterministic background commands and checks.
- Verified results: optional exact account/resource contracts, independent result checks and source-derived execution receipts. See the user guide and feature map.
- Browser work: the Chrome Companion shares tabs and allowed sites from the user's own browser; the task browser runs site-scoped page work with checkpoints, user handoff and submission receipts.
- Skills: reusable cloud instructions and imported SKILL.md references, such as Safe Cleanup for disk-space recovery. A skill does not install its required engine, scripts or dependencies.
- AI Teams (beta): configurable agents with their own model, instructions and scoped resources, in direct or group conversations with visible handoffs.
- Context and memory: relevant prior observations and learned IDs within a chat, plus bounded encrypted personal notes and work summaries users can inspect and delete.
- Device fleet: filter by ownership, tools, workspace and availability before balancing fresh capacity. Projects are not moved implicitly.
- Local control: read-oriented initial setup, explicit file/terminal/browser permissions, trusted roots, sensitive-path checks and supported Local Undo.
- Outbound connectivity: paired Windows, macOS and Linux computers connect outward; no public inbound port or VPN is required.
- Operating controls: versioned plan configuration, Stripe subscriptions and receipts, Credits, funding reservations, separate paid/sponsored budgets and admin usage visibility.
Architecture
flowchart TB
User[User] --> Arc[Arc hosted workspace]
User --> External[External AI client]
External --> Connect[Connect / OAuth MCP]
Arc --> Runtime[Arc runtime and bounded context]
Runtime <--> Model[Configured model API]
Runtime --> Gate[Authorization and dispatch]
Connect --> Gate
Runtime <--> State[(Encrypted content / tasks / usage)]
Scheduler[Leased scheduler] --> Runtime
Gate --> Apps[Cloud App adapters]
Gate --> Route[Device selection and routing]
Route <-->|Outbound authenticated WSS| Agent[Native Go Agent and Execution Core]
Remote Arc is not remote-desktop software, and it is more than an MCP server: it turns AI decisions into authorized, traceable actions. The model is the reasoning component; Remote Arc owns the execution and continuity layer. Provider data, skill text, files and memory remain untrusted observations. Unknown external effects are retained for inspection and are not blindly repeated. A completed run is not a universal semantic proof of success; inspect the returned evidence.
Life of one tool call
- Authenticate. The AI client calls
mcp.remotearc.app/mcpwith an OAuth token scoped to the work it may do. - Authorize. The Worker checks the scope, the account's allowance, device ownership and revocation, and the device's saved tool policy.
- Route. The account's Durable Object forwards the call over the computer's own outbound WebSocket and keeps no copy of the payload.
- Check locally. The Agent re-checks the permission mode, Trusted Write Locations, sensitive paths and, for terminal commands, Safety Guard.
- Execute and record. The Execution Core runs the tool and keeps a Local Undo snapshot for supported edits. The result, usage and activity are recorded.
- Decide again. The AI sees the real observation and chooses the next step. A lost reply is treated as unknown, never silently retried.
Arc runs follow the same gates from step 2 onward, with the model loop running in a Durable Object under a Credits budget. Durable Tasks reach step 3 through a leased scheduler instead of a live chat. Start with ARCHITECTURE.md for the code map, request paths, data stores and contributor rules.
Read the current engineering reference for run state, context reuse, security boundaries, memory limits, scheduling, funding and validation. Public technical documentation explains the same system for users. AI Teams (configurable agents, direct/group conversations and scoped agent handoffs) is a beta release candidate at /dashboard/agent/teams, with its production rollout tracked separately; see the feature map. Cross-run persistent goal continuation and full root-outcome acceptance remain incomplete; see the implementation/design status. Ordinary Connect cannot wake an arbitrary external chat.
Quick start
For hosted Arc, sign in, activate the trial or choose a plan, connect an App and describe your goal. Install a device Agent only for work that needs your computer:
npx remotelink@latest
The npm launcher installs and checksums the native Go Agent and Execution Core. Run npx remotelink@latest to upgrade: an older idle Go Agent is replaced automatically, while active work asks for confirmation. Pairing and permissions are preserved. Standalone and Homebrew installations need no Node.js.
Native downloads and Homebrew
Standalone 0.7.0 needs no Node.js or Go compiler. Installation and upgrade guide.
On macOS or Linux (including WSL), install without Node.js:
curl -fsSL https://remotearc.app/install.sh | sh
The script verifies SHA256 and installs to ~/.local/bin without sudo. On a first install from a terminal it then starts the Agent, so you can pair the computer and choose its permissions. Upgrades, runs without a terminal and REMOTEARC_NO_START=1 only install; start the Agent with remotelink. Set REMOTEARC_INSTALL_DIR to an absolute path to choose another directory. Rerun the installer to upgrade after stopping the Agent.
| Platform | Download |
|---|---|
| macOS Apple Silicon | remotelink |
| macOS Intel | remotelink |
| Windows x64 | remotelink |
| Windows ARM64 | remotelink |
| Linux x64 | remotelink |
| Linux ARM64 | remotelink |
brew tap yaohuangguan/remote-arc https://github.com/yaohuangguan/remote-arc
if brew command trust >/dev/null 2>&1; then brew trust --formula yaohuangguan/remote-arc/remotelink yaohuangguan/remote-arc/remotelink-go; fi
brew install yaohuangguan/remote-arc/remotelink
remotelink
The existing remotelink-go formula remains available for upgrades; install one formula at a time.
For Connect, authorize your compatible AI client against:
https://mcp.remotearc.app/mcp
Pairing a computer and authorizing an AI client are separate, revocable relationships. See installation, Apps, Tasks, Skills and memory.
Monorepo
remote-arc/
├── apps/
│ ├── agent/ Native Go device Agent: pairing, relay, recovery, journals
│ ├── browser-extension/ Chrome Companion: shared tabs and allowed sites
│ ├── ui/ React Arc / Connect / Admin, website, checkout and documentation
│ ├── relay/ Cloudflare Worker: Arc runtime, Apps, tasks, billing, OAuth, MCP and D1 migrations
│ └── mcp/ MCP integration tests against the Go Agent
├── packages/
│ ├── execution-core/ Independent Go module: files, processes, policy, Safety Guard and Undo
│ ├── cli/ npm installer/launcher for the Go Agent
│ ├── protocol/ Shared wire types and plan defaults for Relay and Dashboard
│ ├── skills/ Generated Skill catalog and community Skills
│ └── docs/ Generated documentation and tool index
├── skills/ Source for first-party Skills (for example safe-cleanup)
└── tools/saas/ SaaS pricing and unit-economics models
The Go Agent and Execution Core compile into one executable; extracting the core does not introduce an IPC boundary. The core can be built/tested independently with Go. The cloud Relay and Dashboard remain TypeScript.
Native execution core
Remote Arc implements its local computer capabilities directly with Go and OS APIs.
Current native tools:
list_directory
browse_directories
read_file
read_binary_file
get_file_info
list_processes
write_file
edit_block
list_undo_actions
undo_change
undo_last_change
start_process
process_status
process_output
list_managed_processes
stop_process
The primary core uses Go's os, filepath, os/exec, context and native
platform APIs. It owns bounded process output, cancellation, atomic replacement,
local Undo evidence, conflict fences and path policy. The Agent adds authenticated
outbound sessions, device configuration, checkpoints and local execution journals.
Atomic replacement and explicit durable synchronization are separate policies. TS retains its atomic default; Go retains its durable default. This release does not claim complete hardware power-loss protection. See the persistence validation and system architecture for boundaries and evidence.
Permission model
New devices start with the Safe preset.
Safe
Read-only local capabilities:
list_directory
read_file
read_binary_file
get_file_info
list_processes
The native core also has internal dashboard capabilities such as
list_undo_actions and browse_directories. They let the authenticated
Remote Arc dashboard load local recovery metadata and browse selectable folders
without turning those controls into normal hosted AI skills.
Developer
Safe plus reversible file editing:
write_file
edit_block
undo_last_change
The dashboard can additionally invoke the internal undo_change operation to
restore a selected local snapshot.
Developer mode does not include arbitrary terminal execution.
Full
Developer plus:
start_process
process_status
process_output
stop_process
start_process can run synchronously or return a local process handle for a
managed background process. Output and status stay on the device and are read
through the same authenticated Remote Arc tool path. The dashboard uses the
internal list_managed_processes capability to show these Remote Arc-managed
jobs and lets the user inspect output or stop a running process.
Presets are shortcuts. The actual hosted policy is an individually editable per-device skill list.
Durable Automations
Remote Arc can persist deterministic work independently of the chat session that created it. MCP clients need the separate automation:read / automation:write OAuth scopes to inspect or create persistent work; ordinary computer:write access does not grant that authority.
Four production task modes share the same durable task engine:
- Long task — start a command and keep tracking it after the MCP call/chat ends.
- Condition watch — wait for a webhook event, then execute an approved plan.
- Schedule watch — execute a plan on a recurring interval or at a future time.
- Goal loop — repeat a fixed work plan, execute a verification command, and retry until verification succeeds, the task expires, the run limit is reached, or the user stops it.
Condition watches may also use a cloud-side GitHub App merge action. A matching CI webhook can therefore merge an explicitly configured pull request without depending on a paired computer being online.
Automation state lives in D1 and is advanced by the Worker scheduler or webhook events. Device execution still goes through the same authenticated Durable Object route and the device's existing skill/path policy.
Creating an automation snapshots the current device permission policy. Routine disconnects and local agent restarts do not introduce an approval step: unattended work waits for the device and automatically recovers. If you later change the device security policy itself, Remote Arc stops that automation rather than silently inheriting a different trust boundary.
A device going offline moves eligible work to waiting_for_device; it does not automatically fail the automation. Deterministic long-running work defaults to automatic attempt restart if the local agent reconnects without its previous managed-process handle. For fresh AI judgment, Arc hosted tasks invoke their configured model within current limits. Deterministic Connect tasks need an available supported reasoning host for new decisions; this does not imply an autonomous wake loop into arbitrary external chats.
The background agent and automation engine solve different problems:
- the background agent keeps a paired device available and reconnecting without an open terminal window;
- the automation engine preserves task state and triggers independently of an MCP request or chat lifetime.
A sleeping, powered-off, or disconnected computer is not considered online. Device-backed work resumes only after the agent reconnects.
Running:
npx remotelink --safe
adds a local hard read-only cap that the dashboard cannot expand.
Remote Arc MCP questions
How do I add Remote Arc MCP to Claude Code?
Run claude mcp add remote-arc -- npx -y remotelink in your terminal. Add --scope user to make it available in every project.
How do I add Remote Arc MCP to Cursor?
Open ~/.cursor/mcp.json and add the server under mcpServers, using the Cursor config shown in the install section above.
Is Remote Arc remote-desktop software?
No, it is not remote-desktop software; it is an execution layer that turns AI decisions into authorized, traceable actions.
How do I connect my local computer to Remote Arc?
You can pair a computer for local files, commands, and installed software, which allows the AI to execute tasks on your device.
Do I need to open ports or use a VPN to connect my computer?
No, paired computers connect outward, so no public inbound port or VPN is required.
Can I use my own model API key?
No, users do not need to supply their own model API keys.