Bring your code

Pick your path

All three deliver the same result — a live tool at <username>.ellivate.ai/<slug> with storage, auth, sharing, and a mobile shell wired up. Differences:

Coming from no code at all? Start with Build your first tool instead — that path describes a tool in English and lets Ellivate write the code.

From Claude Code, Cursor, or Windsurf

The deepest integration. Add the Ellivate MCP server to your AI tool once; the next time you ask the LLM to build for Ellivate, it calls Ellivate's tools to learn the conventions (persistence, auth, SDK imports) and writes conforming code from the start. No translator rewrites.

Install (Claude Code)

claude mcp add ellivate \
  --scope user \
  --transport stdio \
  -- npx -y @ellivateai/mcp-server

Restart Claude Code, then verify:

claude mcp list
# ellivate: connected

Install (Cursor)

Settings → MCP Servers → Add server:

• Name: ellivate
• Command: npx -y @ellivateai/mcp-server
• Transport: stdio

Restart Cursor.

Install (Windsurf)

Edit ~/.codeium/windsurf/mcp_config.json:

{
  "mcpServers": {
    "ellivate": {
      "command": "npx",
      "args": ["-y", "@ellivateai/mcp-server"],
      "transport": "stdio"
    }
  }
}

Restart Windsurf.

Use it

Anchor your prompt with what you're building and that it's for Ellivate:

I'm building a reading tracker for Ellivate. Personal books per user, shared reviews across the household. Use the Ellivate MCP tools.

The LLM calls Ellivate's MCP tools — eight guidance tools (persistence, blob storage, collections, reasoning, time, notifications, user-auth, import-path) plus six action tools (publish, doctor, list-apps, get-app, connect-secret, viewer) — to learn the contract and produce code shaped right from the first try.

When you're ready, ask the LLM to publish:

Publish this with the Ellivate MCP publish tool.

Or run ellivate publish yourself in the terminal — same result.

From the CLI

The fastest path for iterating an existing project. One install, one login, one verb to ship.

Install

npm install -g @ellivateai/cli

Verify (Node 20+ required):

ellivate --version
# 0.1.1 (or higher)

Log in

ellivate login

Opens a browser, drops a token back, saves to ~/.ellivate/credentials. Once per machine.

Publish

cd path/to/your/app
ellivate publish

The CLI streams pipeline events:

✓ Uploaded 42 files (1.2 MB)
✓ Classified — Flask (Python 3.11)
✓ Rewrote persistence (3 files)
✓ Wrote auth handoff module
✓ Installed dependencies
✓ Deployed
✓ Live at https://you.ellivate.ai/my-app

First publish of a new app takes 60–90 seconds (the bulk is the container build). Subsequent publishes of the same app reuse infrastructure and take ~20 seconds.

Republishing

Edit the code, run ellivate publish again from the same directory. Same app, same URL, same data.

From the dashboard

Browser-only path. Best when you finished the code in a web-based AI tool (ChatGPT canvas, Claude in the browser) and don't want to install anything.

Sign in

Go to app.ellivate.ai. Free tier is enough.

Drop your project

Click Publish an app and drag your project folder onto the upload zone. Chrome and Firefox support folder drag-and-drop directly; on Safari, or if folder drop isn't working, pick a .zip of the folder instead.

Pick visibility

Two questions before the pipeline runs:

• Public? Public apps show on your profile.
• Requires sign-in? Private defaults to yes; public can go either way.

Both are changeable later from the app detail page.

Watch the pipeline

Same pipeline as the CLI — classify → translate → verify → deploy. Same 60–90 second first publish, ~20s for updates.

Republishing

Drag the updated folder onto the same app's detail page (Replace code). Same URL, same data, new code.

If the gate pauses

On any path, your app may declare it needs configuration before it can deploy — an API key for a third-party service, or a choice about visibility / auth. The publish pauses in NEEDS_CONFIG; the CLI prints a dashboard link, the dashboard shows a form. Fill it in, click Resume, and the pipeline continues. The CLI stays attached and picks up streaming events when the publish resumes.

Common errors

"This app shape isn't supported yet"

The classifier couldn't find a framework it knows how to deploy. Check the supported app shapes list — if your project uses one of them, make sure the entry file (app.py, main.py, package.json with a Next.js dep, index.html, etc.) is at the project root, not buried in a subdirectory.

"Your app uses localStorage for user data"

Ellivate's containers are ephemeral — data in localStorage or local files won't persist. The pipeline auto-rewrites most localStorage usage to ellivate.kv, but if it couldn't (for example, your code stores a non-JSON-serializable value), you'll get a Class 1 blocker with the exact file + line. Fix that one usage and republish.

"Missing lockfile"

Ellivate expects package-lock.json (Node) or a pinned requirements.txt (Python) so dependency resolution at deploy is deterministic. Run npm install or pip freeze > requirements.txt locally before publishing.

"Missing ELLIVATE_DATA_URL at runtime"

The SDK file didn't ship — usually because your project references ellivate-client in a way the injector didn't recognize. Open the dashboard issues tab; there's a specific suggestion for what to change.

See Fix common errors for more.

Iterating

Once a tool is live, you have two ways to update it:

• Edit the code, republish. Standard loop — Claude Code / CLI / dashboard, your pick.
• Describe the change in English. The tool's detail screen has an Edit with AI box that lets the EditAgent make the change for you and republish. Especially handy for quick tweaks when you're on your phone. See AI editing.

What's next

• Flask walkthrough — concrete example from empty directory to live URL.
• The Ellivate contract — what the classifier and translators enforce.
• Ellivate Desktop — Mac launcher that wraps publish + dev + AI tool detection in buttons.