Every model, one allowance.

Go, at five dollars a month. Every plan runs the whole product, so Go is not a trial of a smaller thing: it is the same engine, the same starters and every model tier, with the smallest amount of building a month. People move up when a week runs out before their idea does, and that is the only honest signal that a bigger plan is worth it.

There is no free plan. A turn costs real tokens at a real provider, and the allowance that pays for them comes from a plan, so there is nothing to spend without one. Go is the cheapest way to find out whether this is for you, and it is the full product rather than a sample of it.

Three things. How much you get through in a month, which is worked out from the price rather than typed beside it. Which ceilings lift, since the heavier models arrive on Plus and the frontier ones on Pro, along with priority while the queue is busy. And who else can be in it, since Pro carries five seats and shares one allowance, one bill and one history.

At any time, and it lands immediately. Moving up starts a fresh month from the day you make the change. Moving down keeps the month you have already paid for and starts the smaller plan when it ends, so nothing you paid for is taken away by a decision you made halfway through it.

Websites, web apps and mobile apps. Underneath it is one conversation that reads your files and writes them, so the ceiling is what a browser or a phone can run rather than what a template allows. Landing pages, dashboards, shops with a payment provider, a companion app for a site: all of it goes out as real files you keep.

No. You describe what you want and the agent changes the files. What you get is not a locked visual builder, though: it is an ordinary project of ordinary files, and every one of them is readable, editable and exportable if you or somebody helping you does want to look.

Plain HTML, CSS and JavaScript, TypeScript, React, Preact, Vue, Svelte, Solid, Lit and Alpine, all of them built in the browser from your own files. A Next.js project is supported as source: the files are real and the agent works on them, and the build for deployment happens where your host runs it.

Through Expo, in its repository. Expo is what turns the project into a web build or a store build, and that toolchain runs where the repository runs rather than in this window, so a mobile project is put on GitHub first and the host builds it from there. The workbench says exactly that rather than showing a preview it cannot honestly draw.

The console says what failed and the agent offers to fix it. The repair is narrow on purpose: it is told which file the error names, told not to restyle or add anything, and it suggests the smallest change that makes the file valid. Repairs like that draw on a separate allowance from the turns you ask for, so a broken build does not quietly eat your month.

A credit is a tenth of a cent, so a thousand of them make a dollar. It is the unit the ledger keeps, which is what makes an allowance a sum of money rather than a count of messages: a one line question and a long build are both priced in the same unit, and they cost wildly different amounts of it.

What its tokens cost. A short question on a cheap model is a fraction of a credit, and a long build on the heaviest model is many of them, which is the honest version of what is happening underneath: you are paying for the work, not for a slot in a queue. Every turn is itemised on the Usage screen, so the number is never a mystery you have to trust.

It is a share of what your plan earns. Each month a plan is worth a fixed number of credits, worked out from its price rather than typed next to it, and the weeks inside that month each get their share. Paying for a year takes twenty percent off the price, and the allowance follows the price down rather than staying where it was.

Every week, at Monday midnight UTC. Weeks begin on one boundary for everybody, which is what makes two accounts on the same plan comparable and what lets the server answer the question the same way the screen does. Your own clock is shown next to it, so you never have to work out what UTC means for you. What is left when a week ends does not move forward.

The turn is refused rather than carried on and billed. The refusal says when the window resets, and nothing is charged for work that was not done. One exception exists and it is deliberate: a repair the agent started because a build broke is allowed to finish, because a half finished fix is worse than a spent week.

An email address and a password. Confirmation and sign-in codes are sent by email, so the address has to be one you can open. There is no separate account for the models: one key runs every model call on the installation you are using, so a model is never a second signup.

One control on the Billing screen. Cancelling stops the next charge rather than the current month: what you paid for runs to its end, and nothing is taken away early. You can cancel and come back later, and your projects are waiting exactly where you left them.

It stays, and it is still yours to take. Projects, files, pictures and conversations are not deleted when a subscription ends, they stop being added to. Download a project whenever you like: cancelling is about the next charge, not about the work already done.

From the team screen, where the owner invites by email. The invitation goes to that address, becomes an account when it is accepted, and inherits the role the owner gave it. There is no shared login to pass around and no second password to agree on.

Roles and permissions decide it, and the owner sets them: who may change files, who may publish, who may invite, who may only read. The point of roles here is not ceremony, it is that publishing and inviting are the two things that leave the account and therefore the two that need somebody's name on them.

On a team plan, yes, and that is the point of it: one allowance, one bill, one history, with the work visible to everybody on the plan. What each person uses is countable, because the ledger records turns per account, so a shared month is not an unaccountable one.

You do. The work is your project, in files you can read, and nothing about keeping it requires asking us for anything. The product is a codebase somebody runs, and the same principle covers both halves: what you make here is yours, and what you make it with is yours to keep running.

Download the project. You get a ZIP of its files and the schema of its database, which is a real project rather than a description of one: it opens in an editor, it builds with the tooling its files name, and a live address can be pointed at your own hosting without anything being asked of us first.

A turn sends the files it needs to the model answering it, through the keys this installation holds, and that is the only place your code goes. What a provider keeps from an API request is governed by their own terms, which the person running this installation agreed to on everybody's behalf, and the admin panel is where those keys and models are chosen.

A deploy builds the project and hands you an address anybody can open, no login and no invitation. Publishing is one flow with four short steps, including a check that the project builds and runs before any of it is spent, so a failure costs you nothing but the seconds it took to find out.

No. A project can go out through the hosting this installation is connected to, and the address comes back to you. Connecting your own Vercel account is a choice on the Customize screen, and it is the right choice when the address should belong to you rather than to whoever runs this installation.

Yes. This is a codebase: a Next.js app and a Convex deployment, installed by running the deployment and setting its environment, with the first administrator made by one command rather than by whichever person finds the setup page first. Everything the panel does is yours, including the plans and prices on this page.