Remount

    ____  ________  _______  __  ___   ________
   / __ \/ ____/  |/  / __ \/ / / / | / /_  __/
  / /_/ / __/ / /|_/ / / / / / / /  |/ / / /
 / _, _/ /___/ /  / / /_/ / /_/ / /|  / / /
/_/ |_/_____/_/  /_/\____/\____/_/ |_/ /_/

vmotion for agents

The open-source infrastructure for cloud agents. You bring the harness: Claude Code, Codex, OpenCode, Pi, Gemini CLI, Aider, Goose, Cline, OpenHands, or the loop your product runs. Remount gives it a computer that runs anywhere you have machines and moves between them.

An agent's computer is a workspace. Start it on your laptop, move it to a cloud node when it needs hours or a GPU, and pull it back to inspect. Let it sleep and wake when the PR merges. Give it keys it never sees. Fork it into children. Read every step in an event log. A dropped connection, a dead node, a control-plane restart or a revoked key ends nothing.

10harness recipes, plus your own

1static binary, 1 protocol

4backends: process · docker · gvisor · firecracker

3SDKs: go · python · typescript

4runtime profiles, dev to microvm

0API keys inside a workspace

0hosted services

install

go install remount.dev/remount/cmd/remount@main

hand off, resume, run overnight

# one command from a checkout to a running agent
remount run claude --dir . -- 'add integration tests for the payments module'

# hand a live Claude Code conversation from this laptop to the cloud, then leave
remount handoff --recipe claude --binding b_anthropic --task 'finish the refactor and open a PR'
remount resume $WS                       # tomorrow, from anywhere

# overnight: a queue of tasks, sleeping between them on a durable timer
remount run codex --queue tasks.txt --sleep-after 30m

# a durable agent that pauses when idle, asks before risky egress, forks helpers
remount agent create opencode --dir . --sleep-after 10m --approve on-request -- 'migrate to pnpm'
remount agent fork $AGENT -- 'update the docs to match'
remount ws sleep $WS --on github.pr.merged

quick start (no credentials)

# control plane and one node, in one process
remount standalone --data ./data &
export REMOUNT_SERVER=http://127.0.0.1:7443

WS=$(remount ws create --name hello)
remount exec $WS -- sh -c 'echo hello from $(hostname)'
remount sh $WS                        # interactive shell, real pty

# start something long, hit ^C, come back later
remount exec $WS -- sh -c 'for i in $(seq 1 100); do echo line $i; sleep 1; done'
remount attach $WS <session-id> --from 0

what you can do with it

Hand off and resume. remount handoff copies your checkout and the harness's saved conversation into a workspace and starts the harness there against a brokered key. remount resume reopens that exact conversation from any machine.
Run agents overnight. A task queue runs in one workspace, checkpoints between tasks, sleeps on a control-plane timer and continues on whichever node wakes it. A durable Agent sleeps when idle, wakes on a message or an event, forks children, and parks for approval before an egress you marked sensitive.
Reattach and never lose output. Close the laptop mid-command, come back, attach. The session lives on the node; what retention dropped is an explicit gap, never silence.
Move a workspace mid-task. ws move snapshots the filesystem and a node in the zone you asked for restores it. Files and policy follow.
Hand out keys the agent never sees. The workspace holds a placeholder; the broker substitutes only for allowed hosts, audits every use, and a revocation reaches a live workspace within one renewal.
Drive a browser inside the workspace. Navigate, screenshot, click, type, download files that become artifacts, under the same egress policy as everything else.
Run other people's agents. A node declares a runtime profile and refuses to start unless its backends can prove it; a gVisor node has passed multi-tenant-isolated live, and conformance --profile reports every check as pass, fail or unavailable.

not a sandbox behind someone else's API

E2B and Modal give you a container in their cloud for the length of a request. Remount runs on your machines (or on Modal, Fly and Kubernetes if you like) and treats the agent's computer as something that lasts.
A session is a log, not a socket. Output is kept with sequence numbers; clients replay from where they were.
A workspace is a value. Snapshot, move, sleep and wake, with every grant bound to a generation.
The workspace is trusted with nothing. Secrets, policy and lifecycle live in the node and the control plane.
Lifecycle belongs to the control plane. Leases and idle policy are durable timers, not a setTimeout in your worker.
Everything is an event, committed in the same transaction as the state it describes.
Nothing is hosted. The protocol is public; replace the reference implementation if you can do better.

how it fits together

   your laptop                  control plane                 a GPU box
  ┌────────────┐   outbound    ┌──────────────┐   outbound   ┌────────────┐
  │  remount   │──────────────▶│  claim queue │◀─────────────│  remount   │
  │    up      │   wss:443     │  event log   │   wss:443    │    up      │
  └────────────┘               │  policy      │              └────────────┘
                               │  bindings    │
  ┌────────────┐               └──────────────┘
  │  remount   │──────────────────────▲
  │  exec/sh   │   frames relayed, never interpreted
  └────────────┘

nodes and clients both dial the control plane; nothing needs a public inbound port