# Deploy an App in Three Commands

> Install the client, sign in with the account you already have, and deploy a directory. The whole path from a laptop to a live URL, with nothing to configure.

Published: 2026-09-20  
Canonical: https://agentcell.dev/docs/deploy  
Markdown: https://agentcell.dev/docs/deploy.md

**Three commands take a directory on your laptop to a live URL.** No dashboard to click through, no YAML, no cloud account to create. Sign-ups are open: the first login creates your account.

```sh
agentcell login                    # sign in with Google, GitHub or an emailed PIN
agentcell deploy --cell my-app .   # prints https://my-app.agentcell.cloud
agentcell logs my-app              # watch it start
```

The two fresh-session tests we ran took under eight minutes each, from a directory with nothing in it to a page that survives a reload. Most of that was reading.

## 1. Install the client

One static binary, no runtime. Download it from
[the releases page](https://github.com/AgentCell-dev/agentcell-client/releases/latest), verify it against `SHA256SUMS`, mark it executable and put it on your `PATH` (the client README has the exact lines per platform). With Go installed, it is one line:

```sh
go install github.com/AgentCell-dev/agentcell-client/cmd/agentcell@latest
```

## 2. Sign in once

```sh
agentcell login
```

The browser opens a sign-in page. Pick the account you want to use, Google, GitHub or an emailed one-time PIN, and come back to the terminal. That is the whole registration: your organisation exists the moment the login completes, and the credential is stored on this machine until `agentcell logout`.

On a machine without a browser (a server, a container, an agent's shell), `agentcell login --no-browser` prints a URL and a short code to confirm from any other device.

## 3. Deploy a directory

```sh
agentcell deploy --cell my-app .
```

`deploy` reads the root of the directory and uses the first of three shapes that matches:

| The root holds | What you get |
|---|---|
| a `Dockerfile` | A container cell. It listens on the port the Dockerfile's `EXPOSE` states, 8080 when it states none, and anything written to `/data` survives restarts. |
| a `package.json` with a `build` script | A static site, built on the platform: `npm ci` when `package-lock.json` is present, otherwise `npm install`, then `npm run build`. The first of `dist/`, `build/` or `out/` that holds an `index.html` is served. Vite, Create React App, Vue, Svelte, Astro, and Next.js with `output: 'export'` all work this way. |
| an `index.html` | A static site, served as it is, with no build. |

The client uploads the directory, the platform builds it, and `deploy` prints the URL. Retrying is safe: the same directory maps to the same idempotency key. Then:

```sh
agentcell logs my-app            # runtime logs, --build for the build
agentcell ps                     # every cell you own
agentcell whoami                 # who you are signed in as
```

### Static sites

A static site gets the same private `https://<cell>.agentcell.cloud` address and the same sign-in as every cell. It has no container, no port and no `/data`: the platform's edge serves the files from object storage, and no microVM runs for it. An organisation can have up to 10 static sites.

**Use client 0.1.4 or later for a frontend project.** It leaves `node_modules` and the frontend build caches out of the upload. An older client uploads `node_modules`, and a frontend project then usually exceeds the upload limit. `agentcell version` prints the version you have.

How the files are served:

- `/about` redirects (308) to `/about/` when `about/index.html` exists, and otherwise serves `about.html`.
- With no `404.html`, an unknown path with no file extension gets `index.html`, so client-side routes in a single-page app survive a reload. With a `404.html`, that page is served with status 404 instead.
- Files and folders whose names begin with `.` are not published, except `.well-known/`. Everything else in the output is readable by anyone who can open the site, so never put a secret in it.
- Hashed files under `assets/` are cached by browsers as immutable.
- In `package.json`, `"agentcell": {"output": "public", "spa": false}` overrides the output folder and the single-page fallback.

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, and the samples below include several to copy.

## Try it with a sample

Nine small apps live at [AgentCell-dev/samples](https://github.com/AgentCell-dev/samples). Seven are containers, each with a Dockerfile: a minimal Python page, a notes app that keeps its SQLite database in `/data`, a Go echo server, a Node worker, Next.js, FastAPI and Streamlit. Two are static sites with no Dockerfile: `static-plain`, a folder of HTML, and `vite-react`, a Vite + React app the platform builds.

```sh
git clone https://github.com/AgentCell-dev/samples
agentcell deploy --cell notes ./samples/notes-sqlite
agentcell deploy --cell my-site ./samples/vite-react
```

## From your coding agent

The same binary is an MCP server, so the session that wrote the app can deploy it and read its logs:

```sh
claude mcp add-json agentcell '{"command":"agentcell","args":["mcp"]}'
```

Codex, Cursor, Gemini CLI and any other MCP client point at `agentcell mcp` the same way. The decision criteria and the rules an agent should follow are on the [page written for agents](/docs/for-ai-agents/).

## What is not there yet

- **Sharing a cell with other people** 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.
- `rollback`, `env`, `secrets`, `domains`, `share`, `access`, `spend` and `destroy` are listed by the CLI and answer a typed `not_found` until they ship. So there are no custom domains and no environment variables or secrets yet.
- Detecting a Python or Node server without a Dockerfile is planned. Today only static sites deploy without one.
- Idle container cells do not sleep yet. Scale-to-zero is designed, not shipped; a static site runs no machine in the first place.
- Every cell, static sites included, is behind sign-in. Public sites are not available.