# Elements vs Replit

Replit is an AI app builder made by Replit, Inc. It is an [online platform](https://docs.replit.com/getting-started/intro-replit) where an AI agent, [Replit Agent](https://docs.replit.com/replitai/agent), builds software from a plain-language description, and Replit hosts the result. The agent writes the code, sets up the infrastructure and can test what it built. It builds web apps, mobile apps and other projects, plans larger work as an ordered task list, and saves checkpoints you can roll back to. Replit publishes finished apps to its own cloud and provides databases, storage and sign-in for them. Agent work and hosting are paid for from a plan's monthly credits, with usage-based fees once those run out. You use Replit in a web browser or in its desktop and mobile apps.

Elements plays in the same category, arranged differently. It is an integrated app environment, built for people and their agents: you build an app by asking the AI agent you choose for it, on your own computer. It is one coherent system that includes a project server that runs while you work and a default app framework with sign-in and sessions, background jobs, realtime updates and email, plus a package installer, a test runner, a bundled Postgres database and a deploy command. On every save, the build state is updated almost instantly: the project server builds in milliseconds and answers agents and humans in microseconds. Elements deploys apps over SSH to ordinary Ubuntu servers you rent from any provider. It charges for the tooling, per machine, and meters nothing ([pricing](/pricing)).

The difference is where the work happens, who holds it, and how fast the agent learns what it got wrong. On Replit, your code, your running app and your database live on Replit's cloud. Browser testing of the agent's work, called App Testing, is an optional setting: off in Free Mode, and billed by effort when on. With Elements, your code and your app stay on machines you control. After every edit, one command gives your agent each type error, failing test and broken migration in a single answer, on your own machine, before you open the page. Elements never bills a check, however many the agent runs.

| | Elements | Replit |
|---|---|---|
| Where you build | On your computer, in your editor | In Replit's cloud workspace, in a browser or Replit's apps |
| The agent | The coding agent you choose: Claude Code, Codex, Cursor and others | Replit Agent |
| How the agent's work is checked | After each edit, one answer listing every build error, from failing tests and migrations to type checking and program analysis, then a screenshot in about a second | App Testing: the agent clicks through the app in a browser; off in Free Mode |
| Charge per check | None | Billed by effort, from your credits |
| Where the app runs | Ubuntu servers you control, reached over SSH | Replit's cloud, on Google Cloud |
| Database | Postgres, bundled on your server, or any Postgres 16 or newer | Replit's serverless Postgres, up to 10 GiB per database |
| Background jobs | Part of the app, queued in your database | A Scheduled Deployment, published separately with its own monthly base fee |
| Your app's user accounts | Rows in your own database | Outside your database: Replit accounts, or a separate Clerk tenant |
| Deploy | Sends only the changed files, and goes live only when the tests pass | Publishes a new snapshot of the app |
| Pricing | A subscription per machine, with nothing metered | Plan credits, then usage fees |

## Start on Your Own Computer, With the Agent You Choose

Replit starts in a browser tab: you describe an app, and Replit Agent builds it, with nothing to install.

Elements takes one install, once. After that, two commands give you a running app: `elements create` makes it, and `elements start` opens it in your browser, already running against a real Postgres database on your own machine ([getting started](/learn/man/start)). There is no database to set up, and the code is a folder on your disk. A new project comes ready for your agent.

From there you build with the coding agent you choose. What makes an agent productive is not a platform's integrations but correction: learning what it got wrong the moment it gets it wrong. Replit Agent works inside Replit and its [integrations](https://docs.replit.com/chat/connectors): name a service and the agent "automatically detects these keywords and implements the necessary code and configuration," wired to connections "tied to your Replit account." Each one is another service API in your app and another seam between your app and Replit. An integration saves the agent work only where it could not write the code quickly from standards, and in an app's backend that surface is small; past it, each one costs more to learn and wire than it saves.

Elements ships the plumbing every app needs, keeps abstractions past it to a minimum, and puts its engineering into correction. An Elements app is written in TypeScript, SQL, CSS and HTML, which every capable agent already knows, and its backend is inside the app: a query is a `sql()` call, sign-in is `session.login()`, and a server function is a TypeScript function marked `@rpc`. Its pages use Elements HTML: standard HTML with a light extension for reactive expressions ([html](/learn/man/html)). Elements is one coherent system, so the same build checks each line the agent writes, and `elements build -json` reports each mistake in microseconds. The app deploys to servers that run Ubuntu and speak SSH, which agents know just as well. When a stronger model ships, you can switch to it that day.

## The Agent Checks Its Work After Every Edit

Every AI agent makes mistakes, and Replit says so of its own: Replit Agent's "behavior is probabilistic - meaning it may occasionally make mistakes," according to its [pricing page](https://replit.com/pricing). The question is how soon each one is found.

Replit's agent can check its work with [App Testing](https://docs.replit.com/features/agent/app-testing), where it "navigates through your application like a real user would, clicking around and validating functionality." App Testing is off in Free Mode; you turn it on in Power Mode or Max Mode, and each test is "charged based on the effort spent." Replit's [guide to building with Agent](https://docs.replit.com/learn/build-with-agent) also asks you to check: "After Agent builds, test the app yourself."

In Elements the check is not a setting to switch on. The project server keeps the build graph and build state in memory, which is why it answers in microseconds ([build](/learn/man/build)). After each edit your agent runs one command and gets back every error, with its file and line:

```bash
elements build -json    # ok, or each error with its file and line
```

That answer covers:

- Type errors, in browser code and server code ([typescript](/learn/man/typescript)).
- Failing tests, including a test for an old feature that the change broke. Tests are part of the build, so a failing test is a failing build ([tests](/learn/man/tests)).
- Migration errors. Migrations apply to your development database as you work, and a failing batch rolls back in full, leaving the database as it was ([migrations](/learn/man/migrations)).
- Security mistakes. Calling server-only code such as `sql()` or `session.login()` from code that reaches the browser is a compile error at the call site ([rpc](/learn/man/rpc)).

The agent reads the errors, fixes them and asks again, so by the time you open the page, everything the build can catch is already fixed. A passing build does not prove the page looks right, so Elements also has the agent look: it screenshots and clicks through the route with the Chrome already on your computer, and each look takes about a second ([browser](/learn/man/browser)). Your terminal, your editor and every agent talk to the same project server, so all of them see the same errors ([build](/learn/man/build)).

## No Charge Per Check, and the Check Tells the Agent Where to Look

On Replit, a fix is another request to the agent. [Free Mode](https://docs.replit.com/billing/ai-billing) "supports no-cost everyday Agent work for Core and Pro subscribers within its allowance." Past that allowance, each request in Build Mode creates a checkpoint billed by effort, and Replit's billing page says "Simple requests (like bug fixes or small changes) typically cost less than complex builds." A fix costs less than a build, but it is still billed. Planning can be billed too: "Plan Mode can perform billable reasoning even when it does not change code."

With Elements you pay your agent's provider for its work, as you would with any agent. What Elements changes is how much of that work goes into finding mistakes. The build hands the agent the file and line of each error, so the agent spends its turns fixing errors rather than hunting for them. The check itself runs on your machine, and Elements never bills it.

## Your Code and Your App Stay on Machines You Control

On Replit, your code lives in Replit's cloud workspace. [Publishing](https://docs.replit.com/learn/projects-and-artifacts/replit-deployments) "saves a snapshot of your Replit App to the cloud," on infrastructure that runs on Google Cloud. The production database is Replit's serverless Postgres, with a [10 GiB limit per database](https://docs.replit.com/billing/about-usage-based-billing). If you sign users in with [Replit Auth](https://docs.replit.com/replit-workspace/replit-auth), each of them signs in with a Replit account: "when someone signs in to your app, they are creating or using an existing Replit account," whether they log in through Google, GitHub, X, Apple or email. Replit's other option, [Clerk Auth](https://docs.replit.com/features/auth-and-identity/clerk-auth), puts your users in a Clerk tenant instead: "Clerk Auth creates a separate user store for your app." Either way, the accounts of the people who use your app live outside your app's database, with another company. Clerk Auth "is free for now," and Replit adds that "usage-based pricing may be introduced later."

An Elements app is a folder on your computer. You keep it in Git, on any host. It deploys to any Ubuntu machine you can reach over SSH, and a small VPS works ([deploy](/learn/man/deploy), [DigitalOcean pricing](https://www.digitalocean.com/pricing/droplets)). On the first deploy Elements sets up the machine, with the bundled Postgres, the built-in load balancer and TLS certificates ([what deploy does](/learn/man/deploy/what-happens)). The app runs as one long-lived process on your server. Its database can sit on the same box, which suits a prototype or a single-server app; for several servers, or managed backups and scaling, Elements recommends pointing it at a hosted Postgres such as DigitalOcean Managed PostgreSQL or Amazon RDS ([setup](/learn/man/deploy/setup)). Sign-in is part of the app, and your users are rows in your own database ([authentication recipe](/learn/man/recipes/authentication)).

You hold the code, the server and the database, not only the rights to them. The app is TypeScript, HTML, CSS and SQL on Node.js and Postgres, so any agent can read it.

## Deploys Send Only What Changed, and Go Live Only When the Tests Pass

On Replit, you update a live app by publishing again, which creates a fresh snapshot of it. In Elements, a deploy sends only the files that changed and builds only what they touch. The first deploy to a new machine takes a few seconds; after that, a deploy often lands in under a second ([deploy](/learn/man/deploy)).

Every machine builds the release and runs your tests. Pending migrations run once. Any failure stops the release, and the running app keeps serving until the new release swaps in atomically ([what deploy does](/learn/man/deploy/what-happens)). `elements deploy -json` reports on the local build and on every machine in one answer, so nobody has to log in to a server to find out why a deploy failed.

## If Your Laptop Is Up, Elements Is Up

When you build on a hosted platform, the platform is part of your workflow. Replit's [status page](https://status.replit.com/history) posted 40 incidents between July 1 and September 22, 2026, among them "Published app auth errors," "Publishing is down" and "Publishing is broken due to db migration issue." On a platform, its bad day is your bad day.

Elements runs on your computer, and your app runs on your server. There is no hosted workspace between you and your code, so the project server keeps building whether or not another company's service is up. If your laptop is up, Elements is up.

## Elements' Price Is Known Up Front, With Nothing Metered

Replit bills by usage on top of a plan's credits; Elements bills by machine. Replit's monthly credits ["cover Agent and other Replit cloud services like published apps, storage, and databases,"](https://docs.replit.com/billing/ai-billing) and ["you only pay usage-based fees after your monthly credits are fully used."](https://docs.replit.com/billing/deployment-pricing) On an Autoscale deployment, hosting is billed by compute and requests, so a busier app costs more; a Reserved VM is billed at a monthly rate instead.

Elements is licensed per machine, on a subscription ([licenses](/learn/man/licenses)). Nothing in Elements' price is metered: requests, bandwidth and agent work never appear on the Elements bill. Your agent's provider and your server provider bill you separately, on the plans you pick. The runtime packages such as `@elements/app` are MIT licensed, so the code you ship carries no Elements license.

## Sign-In, Database, Jobs and Email Ship in One Install

Replit's [integrations page](https://docs.replit.com/chat/connectors) lists a database, file storage, Replit Auth and custom domains as "Replit managed", meaning services Replit runs for an app with no setup. Elements ships a database, file storage, sign-in and the rest of an app's backend as parts of one coherent system, not separate cloud services. `elements build -json` type checks and tests the code that uses each part. The parts are:

- Sign-in and sessions, working the same for page requests and server function calls ([session](/learn/man/session)).
- Postgres, bundled and set up for you, with migrations applied as you work ([database](/learn/man/database)).
- File uploads, sent in the same form as the other fields and stored in your Postgres database ([file upload recipe](/learn/man/recipes/file-upload)).
- Realtime: LiveTable keeps a table's rows in sync across every open browser, and channels broadcast messages from the server ([livetable](/learn/man/livetable), [channel](/learn/man/channel)).
- Typed server functions, marked `@rpc`, that the page calls directly ([rpc](/learn/man/rpc)).
- Background jobs, queued in your database, and cron schedules, with no separate deployment ([jobs](/learn/man/jobs)).
- Email written in the same HTML language as your pages ([email](/learn/man/email)).
- Card payments through Stripe Checkout, set up with one secret key ([payments](/learn/man/payments)).

**Background jobs.** On Replit, work that runs on a timer is a separate publish, a [Scheduled Deployment](https://docs.replit.com/features/publishing/deployment-types) with its own [monthly base fee](https://docs.replit.com/billing/deployment-pricing). In Elements, jobs and cron are part of the app: jobs are queued in your database, cron schedules are declared in the app, and the job server starts with the app on your computer and on every deploy machine.

**Realtime.** Replit's integrations page lists no realtime service, so an app that needs live updates builds them itself. In Elements, live updates come with the framework: a page that lists rows from a LiveTable updates in every open browser when a row changes.

**Email.** Replit's [event website guide](https://docs.replit.com/use-cases/launch-event-website) has you connect an email provider, Resend, before you start building. In Elements, mail in development is written to the project server log instead of being sent, so you build and test every message with no email account at all. You add an SMTP provider when you deploy ([email](/learn/man/email)).

## Questions

### Is Elements a Replit alternative?

Yes. You build by talking to an AI agent, as you do on Replit, but the agent works in the project on your computer, and the Elements project server builds each change in milliseconds. The app deploys over SSH to servers you control, and nothing in the Elements subscription is metered.

### Can I move my Replit app to Elements?

Yes. Open the code on your computer and ask your agent to port it to Elements; it reads the existing code as the spec. Every step it takes is checked by `elements build -json`, so failing tests, broken migrations and every other build error in the port come back as errors it fixes.

### Which AI agents can build with Elements?

Any coding agent that can run a command, including Claude Code, Codex and Cursor. Elements works well with any agent because it has a manual built into the binary.

### Does Elements charge for AI agent usage?

No. Elements is a per-machine subscription, and nothing in its price is metered. You pay your agent's provider, such as Anthropic, OpenAI or Cursor, directly, on the plan you choose.

### Where does an Elements app run in production?

On any Ubuntu server you can reach over SSH, from a small VPS upward. Elements sets up the machine, runs Postgres on it, and handles the load balancer and TLS certificates for you.