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.

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, 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:

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

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

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:

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. 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.

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:

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.

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 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.

Deploy an App in Three Commands