# Deploy From Your Agent: Claude Code, Cursor, Codex and MCP

> The agent that wrote the app also ships and runs it. One deploy command, a full-lifecycle MCP server and CLI, structured errors the agent can debug alone — no console required.

Published: 2026-09-19  
Canonical: https://agentcell.dev/resources/deploy-from-your-agent  
Markdown: https://agentcell.dev/resources/deploy-from-your-agent.md

> **TL;DR:** Small software has no operator — one person wanted a tool, and an agent wrote it. So every operation must be usable by the agent, in the same session, without a human translating intent into dashboard clicks: `deploy`, `logs`, `rollback`, `env`, `domains`, `share`, `spend`. The dashboard exists for humans who want it, never because an operation is impossible without it.

## The insight: ride the agents

We do not build a code generator — agents already do that well, and Claude Code, Cursor, Codex, Replit, and Lovable are the top of our funnel, not our competition. Adoption happens *inside a coding session*: the agent finishes the app and deploys it as the last step, rather than the human opening a signup funnel. The integration surface (CLI, MCP server, one-file config) **is** the distribution strategy — and `agentcell deploy` becoming the reflex at the end of a build session is one of the three compounding moats.

## `agentcell deploy`: folder in, URL out

From any directory, with zero config files required:

- **Detection first.** Python (FastAPI/Flask/Streamlit), Node/TS (Next/Vite/Express), and static — target under 30 seconds from command to live endpoint.
- **Escape hatch.** A single optional `agentcell.toml` for anything the detector can't guess.
- **Git-optional.** Git-connected redeploy exists for people who want it; nothing requires a repo.

**Today (September 2026):** static sites are detected. A directory with an `index.html` is served as it is, and one with a `package.json` `build` script (Vite, Create React App, Vue, Svelte, Astro, Next.js with `output: 'export'`) is built on the platform and served from the edge. Python and Node servers still need a `Dockerfile`; detecting them is planned. The [deploy guide](/docs/deploy/) has the exact rules.

## The full lifecycle as tool calls

Deploy is the headline; the discipline is that *nothing is dashboard-only*. The MCP server and CLI cover the whole loop:

| Command | What the agent does with it |
|---|---|
| `deploy` | Build and release from the folder |
| `logs` | Stream and search build + runtime logs |
| `rollback` | Instant recovery to the previous version |
| `env` / `secrets` | Set, list, and scope config without pasting keys into code |
| `domains` | Attach custom domains and certs |
| `share` / `access ls` | Change the share list; inspect who can open what |
| `ps` | What's running, what's asleep |
| `spend` | Current usage before it surprises anyone |
| `destroy` | Remove what shouldn't exist |

Humans use the dashboard for sharing decisions; agents use the API for shipping. Same capabilities, same permissions — the dashboard is a rendering of the API, built second.

## Designed for unaided debugging

When a deploy fails at 11pm with no human watching, the failure must be legible enough that the agent fixes it and redeploys alone:

- **Structured log output** — fields, not wall-of-text.
- **Machine-readable errors with a `hint` field** — what broke, and the most likely fix, in the payload.
- **Exit codes an agent can branch on** — retryable vs needs-a-decision, distinguishable programmatically.

## Scoped tokens: the agent's keys don't open everything

An agent holding deploy rights must not be able to read org secrets or change access lists unless granted. Agent auth uses **scoped tokens** — per project, per capability — so the coding session's key does exactly what the tool needs and nothing else. Convenience without this would be a liability story; see [the membrane](/resources/membrane-security/).

## Honest note

Vercel's MCP server already does deploy-from-files, log streaming, env CRUD, domains, and promote/rollback over OAuth with documented Claude Code setup. "Agent-operable" alone is not a moat — it is one product decision away for funded incumbents. Our edge is that agent operation is the *primary* interface here (not an add-on to a dashboard business), combined with free idle and cheap org identity that dashboard businesses have structural reasons not to copy.

## FAQ

**Which agents work with AgentCell?**
Anything speaking MCP or shell: Claude Code, ChatGPT/Codex, Cursor, generic MCP clients, and plain terminals. One control surface, six ways in.

**Do I ever need the dashboard?**
For sharing decisions (who gets the link) it's the nicest surface. For every operational act, no — that guarantee is the product.

**What if detection guesses wrong?**
`agentcell.toml` overrides detection, and structured errors tell the agent what to set. The 30-second path covers the common cases; the config covers the rest. That file is the design; today a `Dockerfile` at the root always wins, and a static site's output folder and single-page fallback are set with an `"agentcell"` key in `package.json`.

---

*Want your agent to ship, not just write? [Deploy now](/docs/deploy/).*