> Fetch the index of every Tonbo docs page as Markdown at https://tonbo.dev/llms.txt # Concepts Last updated 2 November 2026 > Machines are not open yet. These pages describe Machines as they will open; until then, a create answers [`region_not_offered`](https://tonbo.dev/docs/machines/troubleshooting/manage.md#region_not_offered) (422), “Machines are not offered in any region yet.” Read this before you build: it names the parts of a Machine that every other page refers to, in the order you meet them. A Machine is your container image, run by Tonbo at an HTTPS name. The difference from a server you keep is that it sleeps when no request comes, and every wake starts your image fresh, so what must last goes in its database. ## How it differs from a server or a function you know - Against a server or a virtual machine: you do not keep it running. It sleeps after its last request and pays nothing for compute while asleep, and a request to its name wakes it. - Against a server’s disk: every wake starts with empty memory and fresh root and scratch disks. Its database keeps what your program commits. - Against a function: it runs your whole image, with its ports, from a wake to the next sleep, rather than one handler per request. ## A Machine A named service of your account in one region: an image, its ports, its environment variables, a shape and its sleep settings. It lives until you delete it (see [Manage Machines](https://tonbo.dev/docs/machines/manage.md)). ## Its HTTPS name `https://-.tonbo.sh`, where `` is your username or organization; another port answers at `https://p---.tonbo.sh`. The names stay your account’s for good. ## Ports The ports your program listens on, each private (a key of your account) or public (anyone) (see [Serve requests](https://tonbo.dev/docs/machines/requests.md)). ## Awake and asleep An `active` Machine is `asleep`, `waking`, `awake` or `sleeping`; asleep, it pays nothing for compute (see [Manage Machines](https://tonbo.dev/docs/machines/manage.md#active)). ## Sleep after How long a Machine stays awake after its last request closes: 10 minutes unless you set it, and sooner when it is idle (see [When it sleeps](https://tonbo.dev/docs/machines/sleep.md#sleep)). ## A wake From the request that wakes a Machine to its next sleep. Every wake starts your image fresh, with empty memory and empty disks; its database and its Volume are as they were (see [What a wake starts with](https://tonbo.dev/docs/machines/sleep.md#continue)). ## A stop Every sleep stops the Machine: Tonbo sends your program SIGTERM, waits for it, and turns the Machine off (see [Stopping](https://tonbo.dev/docs/machines/sleep.md#stop)). ## The shape The most vCPUs, memory and scratch disk a Machine may use, from `s-1` (1 vCPU, 2 GiB); the CLI takes `m-8` when you name none (see [Limits](https://tonbo.dev/docs/machines/limits.md#one-machine)). ## Its database One SQLite database per Machine, up to 256 MiB compressed, and one of the two places it keeps data durably (see [Keep data in its database and Volume](https://tonbo.dev/docs/machines/database.md)). ## Its Volume A named block volume of your account, attached to one Machine at a path, for files that must last from one wake to the next. A Machine has at most 1, in its own region, and it stays when the Machine is deleted. Volumes are not offered yet (see [Files on its Volume](https://tonbo.dev/docs/machines/database.md#volume)). ## The image A public `linux/arm64` container image; a tag is fixed to its digest when you name it (see [Deploy a change](https://tonbo.dev/docs/machines/deploy.md#tags)). ## Credit A wake needs credit before it starts (see [Pricing](https://tonbo.dev/docs/machines/pricing.md#credit)). ## How it reaches your program A request to the Machine’s name wakes it if it is asleep, and Tonbo holds the request while it wakes. Your program opens its database as any program opens a Tonbo database. ```text A CALLER: an agent, a browser, a webhook sender | HTTPS, to the Machine's name v TONBO, at the edge of the region wakes the Machine if it is asleep | and holds the request up to 25 s v YOUR MACHINE, awake: your image, started fresh +--------------------------------------------+ | your program --commit--> its database | | memory, processes, files: gone at sleep | +----------------------+---------------------+ | two of three zones hold it: v synced() resolves THE NEXT WAKE: your program opens the database and finds every commit synced() confirmed ``` Every wake starts your image fresh, and its database is a Tonbo database, not a file on the host: a commit is durable once `synced()` resolves, which is why the next wake opens the database and finds every commit `synced()` confirmed (see [Data guarantees](https://tonbo.dev/docs/machines/guarantees/data.md)). ## A Machine, a database and a stream | | A Machine (Not open yet) | [A database](https://tonbo.dev/docs/databases/concepts.md) | [A stream](https://tonbo.dev/docs/streams/concepts.md) | | --- | --- | --- | --- | | Question it answers | Where does my service run, asleep until a request comes? | Where does my program’s state live, so another machine carries on from it? | How do many programs share one ordered log? | | Your program reaches it | HTTPS requests to its name | SQL on a local copy, opened by name | HTTPS requests to its URL, from any language | | Who writes | Your program, writing its own database | One process at a time: the last one to open it | Any number of producers, each retried append once | | Durable when | In its database, once `synced()` resolves; never in memory | `synced()` resolves | The append answers `200` |