Skip to main content

Mental model: Devboxes (workspaces) → save/branch → share

Morph Cloud can be understood at two levels:

  1. Devboxes (recommended): the user-facing object for building and sharing cloud development environments.
  2. Instances (primitives): the underlying VM objects for power users who want fine-grained control over VMs and direct manipulation of snapshots/branches.

Devboxes vs Instances​

If you want…Start with…Why
Day-to-day development (VSCode/Cursor, SSH, tmux agents)DevboxesDevboxes are designed to be programmable workspaces for humans and CLI agents.
Fast prototyping (preview a web app/API, then share it)DevboxesExpose an interactive preview URL and optionally disable auto-sleep to behave like a persistent VPS.
Sharing & collaboration inside an orgDevboxesShare devboxes live via URL with your organization; create multiple orgs as needed.
RL environments, test-time scaling, or bespoke VM orchestrationInstancesInstances + snapshots are the lowest-level building blocks for advanced workflows.

Devboxes are persistent cloud workspaces that can be automated and shared.

  1. Templates: reusable blueprints for dev environments (base snapshot + build steps + integrations).
  2. Devboxes: running workspaces created from a template (or from a snapshot).
  3. Automation & interaction: SSH, HTTP exposure (preview URLs), and tmux sessions for CLI agents.
  4. Save / branch / share: checkpoint state into snapshots, create many parallel workspaces, and share via URLs within your organization.

Common Devboxes flows​

  • Develop: template → devbox → VSCode/Cursor/SSH → tmux automation
  • Prototype: devbox → expose-http → preview URL → iterate
  • Collaborate: devbox → share URL (org) → teammates join
  • Parallel workspaces: devbox → save snapshot → start many devboxes from the checkpoint

Level 2 (primitives): images → snapshots → instances → branches​

The primitives model is still important—it’s just not the default mental model for most users.

Morph Cloud primitives revolve around four concepts:

  1. Images: reusable base OS filesystems (e.g. morphvm-minimal).
  2. Snapshots: immutable, bootable copies of an image (or of a running instance).
  3. Instances: running VMs started from a snapshot.
  4. Branches: near-instant copies of an instance state that let you parallelize work.

When to use what​

  • Use an image when you want a standard starting point.
  • Create a snapshot when you want a reproducible environment you can boot repeatedly.
  • Run an instance when you need a live VM to execute commands, SSH, or expose services.
  • Create a branch when you want multiple parallel futures from the same state.

Common flows​

“Boot and run”​

image → snapshot → instance → exec/ssh/http

“Checkpoint and fork”​

instance → snapshot (checkpoint) → branch (parallel copies)