Do I lose unsaved work when I pause?

No. Pause freezes the whole container, files, processes and all. Resume brings it back exactly as it was. Only finish destroys the container.

Can a paused session resume on a different server?

Yes. The snapshot and the workspace bundle live in Isolation Cloud, so the session comes back on whichever server of the organization you resume it on, with the same views and the same ssh route.

Is the session branch kept after finish?

The work you saved is on the workspace's main branch, and the merged session branch travels inside the workspace bundle. Anything you did not save is gone with the container.

Pause, resume, save and finish

Pause snapshots the sandbox and stops the meter, resume restores it on any server, save merges the branch to the workspace, finish destroys the container.

When you pause an Isolation session, the server takes a snapshot of the sandbox and stops it: the files, the running processes and the agents' state are frozen, and the session's meter stops counting. Resume restores that snapshot, on the same server or another one of the organization, and everything picks up where it was. Save is different from both: it merges the session's branch into the workspace. Finish destroys the container, and only what was saved survives.

The four verbs

Verb	What happens	Command	Action
Pause	snapshot, then stop the sandbox; nothing is lost	`/pause`	`session_pause`
Resume	restore the snapshot and start it again	`/resume`	`session_resume`
Save	commit the session branch, merge into `main`, write the bundle back	`/save`	`session_save`
Finish	destroy the container; unsaved work is gone	`/stop`	`session_stop`

A fifth, /restart (session_restart), recreates the container with the environment's current values, which are baked in at creation. The session id, its files and its views stay; the processes inside stop.

What pause keeps

Pause freezes the sandbox as it is. The runtime, OpenSandbox, captures the container's state as a snapshot that a later create can restore from, and the server marks the session stopped. Nothing is committed, merged or thrown away: a half-written file and an agent halfway through a task are both in the snapshot. Views stop with the sandbox and revive on resume, so the terminals reattach to their tmux sessions and an agent view reopens the same thread. The ssh route id and the public preview label are stable across the pause, so a bookmarked ssh line and a shared link both work again after resume.

While a session is paused it is not measured. CPU, memory and storage samples stop, so the session's cost estimate stops growing. On Cloud sessions, pausing puts the session's machine to sleep: cpu and memory stop billing the moment you pause and only the session's disk keeps billing — a fraction of a cent per hour for most sizes; resume wakes it in about a second, memory and all. Pausing before you close the laptop is how an overnight session costs almost nothing overnight; finishing it is how it costs nothing. Connected Servers never bill either way. The numbers are in Cloud Servers and billing and on the pricing page.

Resume, possibly elsewhere

/resume restores the snapshot and starts the sandbox. Published ports may move on the way back, and the doorman re-resolves them, so the session screen and every view work without a reload. The credential vault is re-installed with fresh scoped tokens on every resume, so the real API keys and git tokens never sit inside a snapshot.

Because the snapshot and the workspace bundle live in Isolation Cloud rather than on a disk you have to reach, a paused session can come back on another server of the organization: the office server that went down is not where your work is. The rule is nothing lives in the sandbox.

/pause
/resume

Save versus finish

Save commits the session branch, merges it --no-ff into the workspace's main, bundles the repository and writes it back with a compare-and-swap on the bundle's ETag. It is safe to repeat and it is the only thing that moves work out of the session.

Finish, /stop, destroys the container. Its row stays in the history with its cost, tokens and time; there is no sandbox to reopen. An agent asked to stop a session asks you first, unless you told it to.

What survives finish, and what does not

Survives, because it lives in the workspace tree and rides the bundle:

The branch. Everything you saved is on main, and the merged session/<id> branch is in the bundle's history.
Agent memory. Each agent's note for this workspace is at /workspace/.isolation/agents/<agentId>/memory.md, read at the start of every turn.
Conversations and the agent's HOME. Threads at /workspace/.isolation/threads/<key>.json and the harness's own session store under the agent's HOME are in the tree, so the same agent view in the next session is the same chat.

Gone with the container:

Packages you installed, caches, build output outside /workspace, and every running process.
Anything on the session branch you did not save.
The environment's materialized variables and secret files, the ssh route, the WebDAV password and the public preview address.

The next session of the workspace starts from a clean image with the current main, which is what makes it safe to hand one to an agent. What a session measures while it runs is in cost, tokens and time.