A computer is a Linux machine of your own, in one of your projects: one container with a shell and a disk, isolated from everything else, with no address of its own. Use it for a coding agent to work in, or for anything you'd rather not run on your laptop — something you just wrote, something you downloaded, a build you don't quite trust, a job that takes all night.
It lives in a project beside that project's services, databases and buckets, shows on its canvas with them, and reaches them by name from its shell (psql postgres://…@postgres:5432, curl http://api:8080). Make one from a project's + Create menu, under Computers in the dashboard, or let an agent make its own with create_computer. (Computers were called sandboxes, and were each a project of their own, until October 2026. Each sandbox became a computer in a project of the same name.)
apt, git, curl, build tools, Python and Node 22 — a machine you can actually work on. As it first starts, Claude Code is installed in it and given Alf's tools for the computer's project, and the computer restarts once so every shell has them. The computer's page shows each step; you can leave and come back, and it carries on where it left off.apt, dnf). A coding agent can still be installed in it later, under Add a coding agent: whatever the system lacks for it (curl, bash) comes from its package manager first.Each kind is one fixed image, pinned, so every computer of a kind is the same machine. Or make one of your own image — anything Docker can pull, a devbox your team keeps on a registry, say: Or an image of your own in the dialog, or alf computer create --image ghcr.io/you/devbox:latest. It's set up as a machine like the rest as it starts (a user, sudo, SSH).
Where there's more than one region, choose which it runs in when you make it; it stays there with its disk. See choosing regions.
A computer is a virtual machine of its own, always on: Linux (Debian, Ubuntu, Fedora or your own image), a user dev with sudo that shells, SSH and startup commands run as, a disk at /workspace of up to 100 GB that is dev's home and goes into snapshots, a system where what you install lasts (up to 30 GB), and an SSH server that's never open to the internet. It's in the project's private network and reaches the project's services by name, like postgres:5432, api:8080 and web:3000. It has no address of its own: nothing outside reaches it until you open a shell, SSH in, share a port, open a TCP port or join its network.
apt or dnf, what you change in /etc, what's in /root — all of it is still there after a restart, after a stop and a start, and after a change that needs a new container. Only choosing another system starts it afresh./workspace of the size you choose (up to 100 GB), billed by its size and made bigger as it runs. It's its user's home, so anything a tool writes to a dotfile — npm's global packages, an agent's config and sign-in, your .bashrc — is there, and its snapshots and copies take it along.dev, with sudo and no password to type. Shells, SSH and startup commands run as dev (coding agents that refuse to run unattended as root are happy); sudo -i is root. On the node and Ubuntu images, the image's own first user becomes dev, so the files it owned stay its.exec tool.sudo makes you root inside that, not on the server.The first time a computer starts, it sets itself up — the user, sudo, an SSH server — which takes a minute; a shell opened before that is root's. A computer started before October 2026 gets all this when it's next restarted.
A computer is always on. Nothing switches it off for being quiet, so you can leave an agent working in it, close the browser and come back tomorrow. (If you'd rather it were, alf computer create --idle 60 makes one that's switched off after an hour with no shell open.)
Stop in its Settings ends whatever is running in it and keeps its container and its disk; Start brings it back with everything in /workspace where you left it. Its size isn't billed while it's stopped (its disk is). While it runs it costs what a service of that size costs: m, a core and 1 GB, is $6 for a month running; see sizes.
It restarts when you say so. Setting a key, putting it on the web or changing its port take effect without touching what's running: shells opened afterwards have them. A new size, too: Settings → Size has a slider over the sizes, xs to 3xl, applied with Apply as it runs (or alf computer resize shop/computer --size xl). A new computer is m (one core, 1 GB), or xl for a coding agent, until you choose otherwise. Giving an agent Alf's tools in the dashboard restarts it once, so every shell, and an agent that was already running, has the token. The few changes that need a new container (turning Docker on, say) wait: the page says so, and they apply when you restart it (Settings → Restart, or alf restart). The one restart outside your hands is the machine itself rebooting — the computer comes back on its own, with what it starts when it starts.
To leave something running after you close the terminal, start it so it doesn't depend on the shell: nohup claude -p "…" > run.log 2>&1 &, or run it in tmux. Closing a terminal ends that shell and what it had in the foreground — not the computer, and not what you started that way. For something that should always run, make it a startup command.
Settings → When it starts lists commands the computer starts as it starts, as dev in /workspace, and starts again whenever one ends — a dev server, a worker, a tunnel of your own. What they print is in its logs, with their name in front. From the terminal:
alf computer startup shop/computer web -- 'cd app && npm run dev'
alf computer startup shop/computer # what starts, and how each is doing
alf computer startup shop/computer --remove webAdding or changing one starts it at once; nothing restarts. For something on a timetable rather than always, a scheduled command on a computer runs in the computer itself, as dev, with what's installed there — like cron on a machine.
Settings → Docker (or alf computer docker shop/computer on) runs Docker in the computer: docker build, docker run -p 8080:80, docker compose up with its services finding each other by name. It takes a restart, and the first start installs Docker (a few minutes); after that it starts with the computer, and dev uses it without sudo.
It's Docker inside a virtual machine, so a few things differ from your laptop: images are stored without overlayfs (they take more room on its system disk), and there's no --privileged and no kernel modules. Containers it runs reach the internet and each other, and -p publishes a port in the computer, which you can share like any other.
What's installed outside /workspace — packages, toolchains, Docker's images — is on the computer's system disk, which can hold up to 30 GB. Its Settings show how much it holds. A computer past that is stopped before it fills the server's disk, and says why; it starts again by itself ten minutes later, for you to make room (sudo apt-get clean, docker system prune, or move data into /workspace), and is stopped again if it's still past the limit. Data belongs in /workspace, which grows as it fills.
A computer's snapshots are of the whole machine: its /workspace and its system — everything installed in it — as they were. Putting one back restores both, and restarts it from what the snapshot kept. (A snapshot's copy off the server has its /workspace only.) See snapshots.
Settings → Make a copy (or alf computer copy shop/computer) makes a new computer in the same project with everything installed in this one and everything in its /workspace, as they are now — set a machine up once, then make as many as you need. Its size, Docker and startup commands come along, and so do its variables; its secrets stay with the original. It's made on the same server, from the computer as it runs.
A computer you make is kept until you delete it. If it's an experiment that should clear itself up, give it a time to go when you make it — a day, a week or a month — and it's deleted, with its disk, when that comes. Keep it… in its Settings changes that at any time.
A computer a coding agent makes goes after a day unless the agent asks for longer, and an agent can keep one a week at most. Keeping one longer than that, or for good, is yours to decide.
Deleting a computer deletes its disk. Its project, and everything else in it, stays.
Usage, at the top of the computer's page, has the same charts as a service's Overview: its memory, CPU and disk over the last hour, day or week. Tight on memory shows up there before it shows up as an agent being stopped.
free and /proc/meminfo still show the memory it started with until it next restarts; what it may use is the new size at once.