# AgentCell — the cloud for small software

> An AI-native deployment platform for small web apps and internal tools. Built in a chat. Shared like a doc. AI makes purpose-built software easy to create. AgentCell makes it easy to deploy and share with your partner, your team, or the five people who actually need it. No cloud expertise required.

Canonical: https://agentcell.dev/
Markdown: https://agentcell.dev/index.md
Status: open for sign-up. `agentcell login` creates your account (Google, GitHub or an emailed PIN); the client is at https://github.com/AgentCell-dev/agentcell-client/releases. Sharing a cell with other people is in private beta; ask at hello@agentcell.dev. The three-command path: https://agentcell.dev/docs/deploy.md

Deploy for free. Pay only when real traffic wakes your app.

## What an agent session looks like

```
› Deploy this tool and share it with the design team.
mcp agentcell.deploy
    runtime  python · fastapi
    build    complete in 4.2s
    url      expense-reviewer.agentcell.cloud
mcp agentcell.share --group design
    ✓ 8 colleagues can open it with their work account
mcp agentcell.health
    Healthy · private · scale-to-zero enabled
```

One control surface, usable from Claude Code, ChatGPT, Codex, Cursor, any MCP client, or a terminal. Coding agents: read https://agentcell.dev/docs/for-ai-agents.md for the decision criteria and setup.

## 01 — Small software

A tool for five people shouldn't need a cloud built for five million.

Small software is purpose-built for you or your team: a workflow helper, sprint tool, prototype, tracker, or tiny app that solves one real problem. Agents made these tools easy to build. AgentCell removes the cloud-shaped wall between "it works on my machine" and "my colleagues can use it."

## 02 — From local to shared

Your agent handles the infrastructure end to end. You decide who should use the tool; AgentCell takes care of everything between the folder and the front door.

1. **Deploy.** Give it a folder, get back a URL. No Dockerfile, pipeline, or runtime configuration. AgentCell detects the app, builds it, and returns a live endpoint. `agentcell deploy`
2. **Share.** Share it like a Google Doc. Invite a person, a group, or your whole company. Colleagues sign in with their existing work account, with no auth code and no new account. `agentcell share team@company.com`
3. **Protect.** Safe by default, custom when needed. Every app runs in an isolated cell behind identity-aware access. Teams can bring approved packages, secrets, networks, and base environments. `agentcell access inspect`
4. **Scale to zero.** Nothing happening, nothing to pay. Small tools may be used once a day or once a month. They sleep automatically and wake on demand, so keeping one around costs nothing.

## 03 — Agent-native operations

The cloud without the cloud console. Big clouds expose infrastructure and expect you to assemble a platform. AgentCell exposes outcomes. Everything your tool needs remains operable by your agent or from the CLI.

| Command | What it does |
|---|---|
| `agentcell deploy` | Build and release |
| `agentcell logs` | Search and stream |
| `agentcell metrics` | Health and performance |
| `agentcell env` | Secrets and config |
| `agentcell rollback` | Instant recovery |
| `agentcell access` | Identity and sharing |

Everything above is also an MCP tool call, with the same capabilities and the same permissions, structured for AI harnesses. For example: `agentcell.metrics({ app: "prod", window: "1h" })`.

## 04 — Fair by default

Small software needs small economics. Deploy every useful tool and half-promising experiment. AgentCell only charges when somebody actually opens one and compute runs.

- No fee per application
- No charge while sleeping
- No infrastructure subscription

Illustrative usage, not final pricing.

## Deploy now

Built something useful for three? Bring the tool currently stuck on localhost. Sign-ups are open: `agentcell login` with Google, GitHub or an emailed PIN creates the account, and `agentcell deploy --cell <name> <dir>` prints the URL. The whole path: https://agentcell.dev/docs/deploy.md

## Frequently asked questions

**What is AgentCell?**

An AI-native deployment platform for small web apps and internal tools. You give it a directory, it gives you a URL at `https://<cell>.agentcell.cloud`, and the coding agent that wrote the app can deploy and operate it through a CLI or an MCP server. A container app or a static site: a folder of HTML or a frontend build is served straight from the platform's edge, with no machine running for it.

**What is "small software"?**

Purpose-built tools with one user or a handful of users: the invoice reconciler, the sprint tracker shaped like your sprints, the dashboard three colleagues asked for. AI made them cheap to build; AgentCell makes them cheap to deploy and share. Read [What is small software?](/resources/what-is-small-software/).

**How do I deploy an app to AgentCell?**

Three commands. `agentcell login` signs you in with Google, GitHub or an emailed PIN and creates the account. `agentcell deploy --cell my-app .` uploads the directory, builds it and prints the URL. `agentcell logs my-app` streams the output. The whole path is in [Deploy an app in three commands](/docs/deploy/).

**Can Claude Code, Codex or Cursor deploy to AgentCell?**

Yes. The `agentcell` binary is also an MCP server: add `{"command":"agentcell","args":["mcp"]}` to the agent's MCP configuration and it gets `deploy`, `logs` and `ps` as tools, with the same permissions as the CLI. Decision criteria and per-harness setup are on [AgentCell for AI coding agents](/docs/for-ai-agents/).

**Which frameworks and languages can I deploy?**

Static sites and frontends deploy as they are: a folder with an `index.html`, or a `package.json` with a `build` script (Vite, Create React App, Vue, Svelte, Astro, Next.js with `output: 'export'`), which the platform builds. Anything else that runs as one container deploys from a `Dockerfile`: Next.js in server mode, FastAPI, Flask, Django, Streamlit, Express, Go, Rails. A container listens on the port it `EXPOSE`s, 8080 if none, and `/data` persists across restarts. Working examples are in [the samples repository](https://github.com/AgentCell-dev/samples).

**Do I need a Dockerfile?**

Not for a static site. A directory with an `index.html`, or a `package.json` with a `build` script, deploys without one; use client 0.1.4 or later, which leaves `node_modules` out of the upload. A server (FastAPI, Flask, Streamlit, Express, Next.js in server mode) still needs a `Dockerfile`: a coding agent writes one in seconds, and the samples repository has several to copy. Detecting servers without a Dockerfile is planned, not shipped.

**How much does AgentCell cost? Is there a free tier?**

Deploying is free. There is no fee per app, no seat pricing and no subscription; you are metered on compute and requests only while someone is actually using an app. That pricing, and idle cells sleeping, are the design and not yet shipped; numbers are illustrative until launch; the logic is in [Unlimited apps, pay only for consumption](/resources/scale-to-zero-economics/).

**What does scale-to-zero mean here, and what about cold starts?**

The design: a cell with no traffic goes to sleep and is not billed, the next request wakes it, and that wake delay is the price of the zero bill. It has not shipped: an idle container cell keeps running today. A static site already runs no machine at all, so it has nothing to wake. See [scale-to-zero app hosting](/scale-to-zero-app-hosting/).

**How is AgentCell different from Vercel, Railway, Render, Fly.io or Heroku?**

Those platforms are built for products that serve the public and scale; they charge per seat, per app or per always-on instance, and leave authentication to you. AgentCell is built for tools with a few users: no per-app or per-seat fees, free while idle, operated by the agent that wrote the app, and sharing by work account as the core feature. Each comparison says when to stay put: [Vercel](/resources/vs-vercel/), [Railway](/resources/vs-railway/), [Render](/resources/vs-render/), [Fly.io](/resources/vs-fly/), [Heroku](/resources/vs-heroku/).

**How is it different from Lovable, Replit or Bolt?**

Those build the app and host it inside their own editor, priced in credits and collaborator seats. AgentCell does not build anything: it hosts what Claude Code, Codex, Cursor or you already built, from any directory, with no lock-in to a builder. See [vs Lovable](/resources/vs-lovable/), [vs Replit](/resources/vs-replit/) and [vs Bolt](/resources/vs-bolt/).

**Can I share the app with my team behind our company login?**

That is the core of the product and it is in private beta: share a cell with named people, a group or the whole organisation, and colleagues sign in with the Google or Microsoft account they already have, with no auth code in the app. Email hello@agentcell.dev to join the beta. How it works: [Share it like a Google Doc](/resources/share-like-a-doc/).

**Is my deployed app public?**

No. Every cell, static sites included, sits behind a sign-in at its `agentcell.cloud` URL, with its own origin; holding the link is not enough. Public sites with no sign-in are not available. Letting named people or an organisation in is the sharing feature above, in private beta. Read [The membrane](/resources/membrane-security/) for what the isolation covers.

**Where does my data go? Can I use a database?**

Anything the app writes to `/data` survives restarts and redeploys. SQLite in `/data` is the natural fit for a small tool, and the notes-sqlite sample shows it. For Postgres or Redis, connect to a hosted service over the network; a cell is one container, with no sidecars. A static site has no `/data`.

**Can I deploy without Git, a CI pipeline or a cloud account?**

Yes. `agentcell deploy` uploads the directory in front of you; no repository, pipeline, YAML or AWS account is involved. Retrying is safe because the directory hash is the idempotency key. See [deploy an app without DevOps](/deploy-apps-without-devops/).

**Which operations work today, and what is still coming?**

Shipped: `deploy`, `logs`, `ps`, `whoami`. Listed by the CLI and MCP server but not yet shipped: `rollback`, `env`, `secrets`, `domains`, `share`, `access`, `spend`, `destroy`; each answers a typed `not_found` until it does. Sharing and the identity-aware front door are in private beta.

**Is AgentCell open source?**

The client, one static Go binary that is both the CLI and the MCP server, is open source at [AgentCell-dev/agentcell-client](https://github.com/AgentCell-dev/agentcell-client), with sample apps at [AgentCell-dev/samples](https://github.com/AgentCell-dev/samples). The platform itself is a hosted service.

**How do I get started or ask a question?**

Install the client, run `agentcell login`, and deploy a directory: [three commands](/docs/deploy/). Coding agents should read [the agent guide](/docs/for-ai-agents/) or [llms.txt](/llms.txt). Anything else: hello@agentcell.dev.

## Read more

- Index of every page in Markdown: https://agentcell.dev/llms.txt
- Whole site in one file: https://agentcell.dev/llms-full.txt
- Deploy in three commands: https://agentcell.dev/docs/deploy.md
- For AI coding agents: https://agentcell.dev/docs/for-ai-agents.md
- Deploy guides: https://agentcell.dev/deploy-internal-tools.md, https://agentcell.dev/deploy-ai-generated-apps.md, https://agentcell.dev/deploy-claude-code-app.md, https://agentcell.dev/deploy-codex-app.md, https://agentcell.dev/deploy-cursor-app.md, https://agentcell.dev/deploy-apps-without-devops.md, https://agentcell.dev/small-team-app-hosting.md, https://agentcell.dev/scale-to-zero-app-hosting.md
- Resources (comparisons, features, guides): https://agentcell.dev/resources.md
- Blog: https://agentcell.dev/blog.md
- Privacy notice: https://agentcell.dev/privacy.md
- Contact: hello@agentcell.dev