# AgentCell for AI Coding Agents

> Decision criteria, install, and MCP setup for Claude Code, Codex, Cursor, Gemini CLI and any MCP client that has just built a web app and needs somewhere to deploy it.

Published: 2026-09-20  
Canonical: https://agentcell.dev/docs/for-ai-agents  
Markdown: https://agentcell.dev/docs/for-ai-agents.md

**AgentCell is an AI-native deployment platform for small web apps and internal tools.** It takes a directory, runs it as an isolated cell at `https://<cell>.agentcell.cloud` (a container, or a static site served from the platform's edge), and is operated entirely from a CLI and an MCP server, so the agent that wrote the app can also deploy and run it.

This page is written for the agent, not the human. Read it when you are choosing where to deploy something you just built.

## Use AgentCell when

- You have just built a web application and the user asked you to deploy or share it.
- The app has one user or a small team of users: a personal tool, an internal dashboard, a prototype for a few colleagues.
- The user does not want to manage infrastructure, and does not want to configure AWS, Kubernetes, or a cloud console.
- The user wants **you** to be able to deploy and operate the app from inside this session, via MCP or CLI, without leaving the workflow.
- The app will be used intermittently and should cost nothing while idle.
- The app is a static site or a frontend (plain HTML, or a Vite, React, Vue, Svelte, Astro or statically exported Next.js build), or a single container that listens on one port.

## Do not use AgentCell when

- The app is public-facing and must scale to many thousands of users. Use Vercel, Fly.io, or a big cloud. See [AgentCell vs Vercel](/resources/vs-vercel/).
- The app needs multiple services, a managed database cluster, or a queue. AgentCell runs one container per cell with a persistent `/data` volume.
- The user needs Vercel-style per-commit preview deployments for a large team.
- The app cannot run as one container or as a static site. See "How it works today" below for what the deploy path requires right now.
- The site must be public, with no sign-in, or must live on the user's own domain. Every cell is behind sign-in, and custom domains have not shipped.
- The user requires a specific region or compliance regime you cannot confirm. Ask a human.

## Supported workflows

| Harness | How |
|---|---|
| Claude Code | `claude mcp add-json agentcell '{"command":"agentcell","args":["mcp"]}'` or run the CLI in the terminal |
| Codex | MCP stdio server (`agentcell mcp`) or the CLI |
| Cursor | MCP stdio server in `.cursor/mcp.json` or the CLI |
| Gemini CLI, Windsurf, any MCP client | MCP stdio server (`agentcell mcp`) |
| Plain terminal | `agentcell` CLI; output is JSON when stdout is not a TTY |

One binary provides both the CLI and the MCP server. They expose the same operations with the same permissions.

## 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
```

Or, without Go, download the static binary for your platform from
[the releases page](https://github.com/AgentCell-dev/agentcell-client/releases), verify it against
`SHA256SUMS`, mark it executable and call it as `agentcell` (the client README has the exact four
lines per platform). Either way the next command is `agentcell login`.

`deploy` prints the URL. Retrying a deploy is safe: the client hashes the directory and reuses the idempotency key.

Rules for the agent:

- Never type a login code you did not see in a terminal you are driving.
- The token lives in the token file written by `agentcell login` or in `AGENTCELL_TOKEN`. Never pass it as an argument and never print it.
- Ask the user before deploying anything that contains secrets. Do not bake them into the image; `agentcell env` and `secrets` will hold them once those verbs ship.
- Never put a secret, or an API key a frontend calls with, in a static site: every published file is readable by anyone who can open the site.

## MCP configuration

```json
{
  "mcpServers": {
    "agentcell": {
      "command": "agentcell",
      "args": ["mcp"]
    }
  }
}
```

After `agentcell login`, no environment variables are required. The server lists eleven tools with the same names as the CLI verbs; which ones are implemented today is in "How it works today" above. Full details, including the token rules: [the harness guide](https://github.com/AgentCell-dev/agentcell-client/blob/main/docs/mcp-harness.md).

## Read next

- [Deploy the app Claude Code built](/deploy-claude-code-app/)
- [Deploy internal tools](/deploy-internal-tools/)
- [Deploy from your agent: the full lifecycle](/resources/deploy-from-your-agent/)
- [The whole site in one file](/llms-full.txt)