ellivate.ai

Concepts

AI editing

Open a published tool, describe a change in plain English, the EditAgent reads the source, makes targeted edits in a sandbox, and republishes. Lives on mobile and on the web dashboard. The same primitive that lets a non-technical builder turn an idea into a tool keeps that tool evolving without ever touching code.

The shape of an edit

Every published tool exposes an "Edit with AI" box — mobile app on the tool's detail screen, web dashboard on the same place. Type what you want changed:

  • “Add a notes field to each entry.”
  • “The trip dates are wrong — change July 12-19 to July 5-12.”
  • “When I open a recipe, show the ingredients first, then the steps.”
  • “Send me a push at 8am every day asking what I ate yesterday.”

The agent reads the project, plans the change, edits the files it needs to edit, and republishes. The whole loop finishes in a couple of minutes. You see the edit go live; if the agent couldn't pull it off, you see why and can retry with more detail.

What the agent can do

  • Add features. New routes, new fields, new UI elements, new push notifications. Tools the SDK exposes (collections, scheduled handlers, reasoning calls) all available — the skill that ships with Ellivate teaches the agent which one to reach for.
  • Modify behavior. Change a sort order, tweak a UI label, fix a bug a user described.
  • Edit data. Read or update what the tool has stored — useful for “the dates I entered are wrong” cases where you want the existing rows fixed, not just the form that creates them.
  • Refactor the layout. Reorganize a page, split a component, split one screen into two.

What it won't do

  • Edit Ellivate's own files. ellivate-client.js, ellivate_client.py, the auth-handoff middleware, anything Ellivate writes during publish. Those are off-limits — touching them would break the contract that lets your tool talk to Ellivate's cloud. The agent rejects requests that target them.
  • Change frameworks. Flask stays Flask; Next.js stays Next.js. If you want a different shape, start a new tool.
  • Run unbounded. Each edit has a turn cap (currently 25 tool calls). When the cap hits, the agent stops with a clear “couldn't finish this in 25 steps” message rather than spending more credits.
  • Touch your secrets. Connection credentials and AI keys never appear in the sandbox the agent works in.

How the sandbox works

The agent never edits your published tool's live source. Each edit run materializes the latest source into a fresh temp directory; the agent reads, writes, and deletes files there. When the loop finishes, that directory feeds back into the publish pipeline — the same one ellivate publish uses — and your live URL updates when the deploy succeeds.

If the deploy fails, your previous version stays live. The agent run is recorded as a failed edit you can review; nothing breaks the working tool you had before the request.

The agent has a small typed toolbox: read_file, write_file, delete_file, list_directory, read_kv, write_kv. It can't shell out, fetch arbitrary URLs, or run code — those would be paths to silent corruption of state we couldn't replay.

Where it costs you

The agent calls an LLM (Claude Sonnet by default) to plan and execute each step. Those calls draw against your plan's included inference bucket, same pool as ellivate.reason(). A typical edit is small; a complex refactor with many file reads costs more. You'll see the exact draw on the dashboard's billing tab after each edit.

Two ways to keep editing past Plus's included bucket: upgrade to Premium for a much larger bucket (plus higher rate limits and unlimited tools), or switch to BYOK and bring your own Anthropic key so you pay the provider directly. Either lane covers AI editing, the “create from prompt” flow, and any ellivate.reason() calls inside your tool. See Pricing & credits for the full picture.

Where you'll see history

Every edit run creates a Build row visible from the tool's detail screen. You see what you asked for, what the agent did, whether the deploy succeeded, and (when something went sideways) the error trace. Two pieces of this matter:

  • Edit history is yours. If a recent edit broke something, the previous build is one click away — roll back to the last green publish.
  • Failed edits don't silently consume. The agent prints a reason. If you ran out of turns, you see which file it last touched. If it refused to edit a protected file, you see which file. If the deploy failed, you see the deploy error.

How it relates to building from scratch

Two ways an Ellivate tool comes to life: build it elsewhere and bring it (Claude Code, Cursor, Windsurf, raw prompting) → ellivate publish. Or skip the IDE entirely — describe the tool you want on mobile or in the dashboard, let Ellivate build the first version, then iterate by AI editing. Both paths land at the same place: a live tool with a vanity URL you can share. The second path keeps you in the same flow as you grow the tool.

What's next