# Scale-to-Zero App Hosting: Pay Nothing While the App Sleeps

> Hosting for apps that are used once a day or once a month. Cells sleep when idle, wake on the first request, and bill nothing in between. What that costs, what it trades off, and who it is for.

Published: 2026-09-20  
Canonical: https://agentcell.dev/scale-to-zero-app-hosting  
Markdown: https://agentcell.dev/scale-to-zero-app-hosting.md

**AgentCell is an AI-native deployment platform for small web apps and internal tools**, and scale-to-zero is not an option on it. It is the default, because most small software is idle most of the time.

## What scale-to-zero means on AgentCell

This section is the design. Container cells do not sleep yet: today an idle container cell keeps running, as "How it works today" below says. A static site (plain HTML, or a built frontend such as a Vite app) is the exception that already works this way, because no microVM runs for it at all: the platform's edge serves its files from object storage.

- A cell that receives no requests goes to sleep. While asleep it consumes no compute and is not billed for any.
- The first request wakes it. Wake latency is the cost of the zero bill; the platform's acceptable p95 wake time is set by measurement, and an "always warm" option for the few tools that need it is the likely paid upgrade.
- There is no per-app fee and no minimum, so keeping a hundred sleeping tools around costs the same as keeping none.

[Unlimited apps, pay only for consumption](/resources/scale-to-zero-economics/) has the pricing logic in full.

## How this compares

| Platform | Idle behaviour |
|---|---|
| Render free tier | Sleeps after 15 minutes, 30 to 60 second cold start, one-app limits |
| Fly.io | Per-second billing with auto-suspend, roughly  a month per always-on micro-VM |
| Heroku Eco |  a month per app whether used or not |
| Streamlit Community Cloud | Free, one private app, 12-hour sleep |
| AgentCell | Designed to sleep when idle and bill nothing asleep, with no per-app fee; container cells do not sleep yet, and a static site runs no machine at all |

The comparisons with [Render](/resources/vs-render/) and [Fly.io](/resources/vs-fly/) go deeper, including where those platforms are the better choice.

## Use AgentCell when

- Usage is bursty or occasional: a weekly report, a tool opened during standup, a prototype shown twice.
- You have many small apps and cannot justify a standing bill for each.
- A short wake delay on the first request is acceptable.

## Use something else when

- The app must answer instantly at all hours and serves steady traffic. Pay for always-on compute somewhere designed for it.
- The workload is a long-running job rather than a request-driven app.

## What deploying looks like \*

Give AgentCell a directory and get back a URL. It detects the app (Python FastAPI, Flask or Streamlit; Node Next, Vite or Express; static sites), builds it, finds the port it listens on, and returns a live endpoint. Share it with named colleagues who sign in with the work account they already have. Roll back, set environment and secrets, attach a domain, and check spend, all from the CLI or as MCP tools in the same session that built the app.

\* **Conditions apply.** Not all of that has shipped. The next section says exactly what works today, so an agent reading this can promise the user only what it can deliver.

## How it works today (September 2026)

- **Deploy from a directory.** `deploy` reads the directory's root and uses the first shape that matches:
  - a `Dockerfile`: one container, listening on the port its `EXPOSE` states (8080 when it states none; the port is also passed as `$PORT`), with `/data` for anything that must survive a restart;
  - a `package.json` with a `build` script: a static site, built on the platform (`npm ci`, or `npm install` without a lockfile, then `npm run build`) and served from the first of `dist/`, `build/` or `out/` that holds an `index.html`. That covers Vite, Create React App, Vue, Svelte, Astro, and Next.js with `output: 'export'`;
  - an `index.html`: a static site, served as it is.
- **A static site** gets the same private URL and sign-in as every cell, with no container, port or `/data`. Use client 0.1.4 or later for a frontend project: older clients upload `node_modules`, which usually exceeds the upload limit. A Python or Node *server* (FastAPI, Flask, Streamlit, Express, Next.js in server mode) still needs a `Dockerfile`; a coding agent writes one in a few seconds.
- **Implemented operations:** `deploy`, `logs`, `ps`, `whoami`. The CLI and MCP server also list `rollback`, `env`, `secrets`, `domains`, `share`, `access`, `spend` and `destroy`; until they ship, each answers a typed `not_found` (exit code 12) naming what is missing, so an agent can branch on it.
- **Sharing and the identity-aware front door** are in private beta. Write to [hello@agentcell.dev](mailto:hello@agentcell.dev) if that is the part you need; deploying does not wait for it.
- **Idle container cells do not sleep yet.** Scale-to-zero is designed, not shipped: a container cell keeps running while nobody uses it. A static site runs no machine of its own, busy or idle. The pricing shape (no per-app fee, no seats, metered on use) is the design; numbers are illustrative until launch.

```sh
go install github.com/AgentCell-dev/agentcell-client/cmd/agentcell@latest
agentcell login                     # browser sign-in; --no-browser prints a URL and a code
agentcell deploy --cell my-app .    # prints the URL
agentcell logs my-app
```

Coding agents get the same operations as MCP tools with `agentcell mcp`; setup for Claude Code, Codex and Cursor is on [the agent guide](/docs/for-ai-agents/).