Every scene has a chat panel. Describe what you want and the assistant builds it in the scene you have open, using the same APIs the editor's own panels use — everything it makes is an ordinary object, material, script, or asset you can then edit by hand.

In a desktop window, type your request in the field at the end of the dock along the bottom of the viewport ("Ask AI to build or change this scene…") and press Enter or the Generate button. Shift + Enter adds a new line, and Cmd/Ctrl + Enter also sends. Sending opens the Generate with AI panel, which the AI button at the top of the editor's right-hand rail also opens and closes. The panel holds the conversation, where you can click an earlier prompt to use it again, open Review changes, rate a reply or answer a question form, along with the model picker, how much of your plan's AI is left, Do this on a new branch on Studio, and any error, such as a refused request with a link to add credits or upgrade. It shares the rail's one panel slot with Objects, Properties and the libraries, so opening one of those hides the conversation until you press the AI button again; a turn keeps running meanwhile, and the AI button shows a dot until it finishes. When a turn fails, its status reads Failed to generate a response; hover over it for the reason. If the chat later gets past a failure, its status keeps a note such as "Recovered after 1 failed attempt", and hovering over the note shows the last of those errors. On phones and small tablets the dock has no AI field. Open the Generate with AI panel with the same AI button on the rail, type into the field at the bottom of the panel ("Describe a change…") and press its Generate button. Return adds a new line there, and Cmd/Ctrl + Enter sends from a keyboard. See "Workspace panels" in Editor basics.

It is not a separate mode. Changes appear in the viewport as they are made and are saved as they happen. They are not added to the editor's undo history, so Cmd/Ctrl + Z does not reverse them — and undoing one of your own earlier edits leaves alone any object the assistant has changed since. To back out, use the chat's Review changes (see "Undoing what it did" below), ask the assistant to put it back, or edit the object by hand.

What it can build

Scene objects — create, update, and delete, one at a time or in batches. Shapes, characters, cameras, lights, water, GUI elements (including HUD text styled bold, outlined or drop-shadowed), soft bodies, and particle emitters for smoke, sparks and explosions. For a repeated group, such as a row of tents or a fleet of trucks, it builds one and copies it with its children, scripts and materials, rather than making each copy from scratch.
Layout — it plans spatial arrangements and GUI layouts before placing anything, rather than guessing coordinates one object at a time.
Materials and shaders — it reuses a project material that already matches before making a new one, so asking for "a red crate" twice does not leave you with two identical red materials. Given a texture set you have uploaded, it can build a standard or physical material with its colour, normal, roughness, metalness and ambient-occlusion maps, tiled across the surface (see Assets, materials, and shaders). Shader effects go through a specialist that writes the GLSL.
Lua scripts — object scripts and scene scripts, including attaching a scene script to the scene so it actually receives player actions.
Vehicles — wheeled and tracked, each arriving with a driving script already attached.
Generated assets — procedural PNG textures, GUI images and transparent particle sprites made from patterns, gradients, seeded noise and shapes; noise height maps for terrain; meshes built from solids with holes cut or parts fused, extruded or revolved profiles, swept pipes and trim, and seeded rock formations; swept road and race tracks; sky panoramas with a gradient, sun or moon, stars, clouds and mountains, which it makes the scene's skybox; and short sound effects, from starting points such as a coin, laser or explosion or built voice by voice, for scripts to play. A generated mesh can carry a separate material on each part, such as a red roof on white walls. It can also read back the recipe of one it made earlier and rebuild it in place, so every object already using it picks up the change.
Player controls — configuring the scene's input scheme and action buttons, including each action's gamepad button and whether it shows on touch.
Sky, skybox, environment lighting, fog, tone mapping, bloom, ambient occlusion, reverb, performance and gravity — the scene's sun position and atmosphere, a skybox image drawn in place of that sky, optional lighting and reflections on Standard and Physical materials from the visible sky, distance fog, tone mapping and exposure, bloom, ambient occlusion (soft contact shadows), the reverb on its sound effects, the Performance settings for weak graphics hardware (point light budget, render scale and adaptive resolution), and its world gravity, with the same ranges as Scene Settings. Environment lighting is off by default; ask to enable it and set its intensity separately from background brightness. Test on your target devices before using it for phone-first games. When it adds local lights such as lanterns or torches it gives each one a range, and for a large scene with many of them it can also set a point light budget; see "Performance: point light budget and render scale" in Editor basics.
Ephemeral Lua — it can run throwaway Lua against the open scene to inspect it, the same thing the editor Lua REPL does.
Publish readiness — after building or changing a multiplayer game it runs the same checks as the project's Publishing section and fixes what they find, such as players with nothing to control or a camera that does not follow each player. Publishing itself stays a button you press.

Reusing the account library

The assistant can list reusable prefabs, assets, scripts, materials and shaders saved in the current account, save a source from the current project when you ask to preserve it for reuse, and import a chosen saved revision into the current project and scene. For example: “Save this enemy and its children to the account library,” or “Add revision 2 of the Goblin prefab here.” Existing-item saves require its current revision number, so a stale save is refused.

Each library save keeps an immutable revision and its files independently of the source project. Each import creates independent copies; existing project copies never update automatically. Prefabs include children and resource dependencies. External object links, unknown Lua UUIDs and multiplayer weapon bindings are refused, and game settings are not captured. See Account library in Editor basics.

Library changes are account content. Project checkpoints, Review changes and Revert this turn do not undo a library save or changes made to the account catalog. Imported copies are ordinary project content, so project history can review and revert those copies. The assistant has library list/save/import tools; manage item details and deletion in the Account library interface.

It will ask before guessing

When a request leaves something open that cannot be safely inferred — which of three plausible materials you meant, how big "a large room" is — the assistant stops and puts a short form in the chat rather than picking for you. Questions come with suggested options, and most also accept free text if none of them fit. Answer the form and it carries straight on with the work.

This is deliberate: a wrong guess early in a build is expensive to unpick once forty objects depend on it.

Handing it a broken object

If an object fails to load, the panel that reports it has a Copy button — see When an object fails to load. What it copies is written for the assistant: the object's id, the error, and the object's stored data, so pasting it into the chat gives the assistant everything a repair needs without it having to go looking. Copy all does the same for every object in the panel at once. The panel's not saved to server rows — objects the server refused to save — copy the same way, with the server's reason, so the assistant can fix the data before the next load drops them.

Explaining a script

To understand a script rather than change it, open it and press Explain script under the code in the Edit Script dialog, or select some lines and press Explain lines N–M. The explanation walks through the code, names the concepts it uses and marks things to check on their lines. Any fix it suggests is applied only when you press Apply to draft, and saved only when you save the script. It is separate from the chat: it does not appear in the conversation and never edits your project. See "Explaining a script" in Editor basics.

An explanation comes out of your plan's AI and then your credit, the same as a chat message (see the Cost row below), and is refused with the same message once both are used up.

What it cannot do

The assistant works inside one scene at a time — the one you have open. Anything above that level is yours to do in the editor:

Creating, renaming, archiving, or deleting projects.
Creating, deleting, or switching scenes. Ask it to build in a scene by opening that scene first.
Configuring multiplayer settings — player limits, the authority action schema, weapon and entity templates, and presentation events.
Publishing a game or managing releases. It can tell you whether the game is ready, but publishing is yours to do.
Deleting materials, shaders, or assets. It can create materials and update them, create shaders, and rebuild an asset it generated, and it can delete a script, but clearing out unused resources is done in the editor's library panels.
Editing an existing shader's GLSL. It writes a new shader instead; change an existing one in the shader editor.
Adding an asset from a file or a URL. It can generate assets from parameters and reuse saved account-library assets; upload new models, textures, and sounds yourself, or use an MCP client, which can import from a URL.

Work on a branch

On Studio, the chat panel on main offers Do this on a new branch. Select it before submitting your request to copy the whole project, queue the AI turn against the corresponding scene in that branch, and open the branch. The assistant still works on the scene you asked from, using the branch's separate working copy.

Review the result with the branch drawer's Review changes. You decide whether to merge it into main; the in-editor assistant has no merge tool. Later messages sent on that branch keep editing it. Checkpoints, turn reviews and reverts apply to the project copy where the turn ran. See Project branches and version history for conflicts, merging and closing a branch.

Undoing what it did

On the Creator and Studio plans, a checkpoint of the whole project is taken before every turn, named Before AI: followed by the start of your message, and another when the turn ends, named After AI:. The second is taken whether the turn finished or failed, since a failed turn may already have changed things.

Reviewing and reverting one turn

A chat whose turn changed something shows Review changes in the chat history, with a count such as "12 objects, 2 scripts". It opens Version history on that turn, listing every object, script, shader, material, asset, scene and project setting the turn changed, field by field. Each change is marked with where it stands now:

a checkbox: still exactly as the assistant left it, so it can be taken back;
Edited since: changed again after the turn, by you or anyone else. A revert leaves it alone;
Reverted: already back to how it was before the turn;
Kept, with a reason: taking it back would break something made since. For example, an object the turn added that something has since been put under, a material the turn added that an object now uses, or the scene players start in.

Revert this turn takes back every ticked change. Untick any you want to keep, and the button becomes Revert N selected. Everything done since the turn stays as it is, which is the difference from restoring the Before AI checkpoint. Like a restore, a revert saves a checkpoint of the project first, so it can be undone, and every open editor reloads. It is refused while any AI turn on the project is running.

A revert works on whole objects, not single fields. If you changed one field of an object the assistant also changed, the whole object shows as Edited since and keeps both its changes. Undo that one by hand, or restore the checkpoint.

Restoring the checkpoint from before it

To put the whole project back as it was before a turn, open Version history and restore the Before AI checkpoint. Everything goes back, including assets it generated or replaced, and so does anything changed after the turn. A restore is refused while a turn is still running: wait for it to finish, or stop it, first. To see what restoring it would undo, open the checkpoint's change view with Show changes.

Checking its own work

On the same plans, the assistant can compare the project with the checkpoint taken before its turn. After a change in several steps, it checks once that the result matches what you asked for and that nothing else changed, and fixes any difference before it replies. You can also ask it "what did you change?" to get an answer read from the project rather than from memory. The comparison includes anything you edited yourself while it was working, and it leaves your edits alone.

How this differs from connecting an MCP client

Both drive the same editor. The difference is where the model runs and how much it already knows.

	The AI assistant	An MCP client
Setup	None. It is in every scene.	Add the server URL and authorize with OAuth.
Scope of work	The one scene you have open.	Every project and scene in the account, including creating and deleting them.
Knowledge of the editor	Built in. It knows the object types, the Lua API, and the conventions without being told.	Whatever the client's model knows, plus the tool descriptions.
Asks clarifying questions	Yes, through a form in the chat.	Depends entirely on the client.
Cost	Comes out of your plan's AI first — a little every day on Free, with extra in your first week; more each month on Creator, and 3× that on Studio — then out of any credit you have added. The chat panel shows how much of your plan's AI is left and when it resets. When it and your credit are both used up, the chat says when your plan's AI comes back and, for an account admin, which plan has more.	Billed by whoever provides the client's model.

They are not exclusive, and an MCP client is the better tool for work that spans scenes or projects — bulk edits, migrations, generating a dozen variations of a level. See Connect an MCP client.

Getting better results

Say what it is for, not just what it is. "A ramp the player can drive a car up" produces a different ramp from "a ramp".
Build in passes. Ask for the layout, look at it, then ask for the scripting. A single enormous request gives you less to correct mid-flight.
Name things. Once an object has a name you can refer to it later — "make the Crate heavier" works; "make that box heavier" depends on what it thinks you were looking at.
Tell it what went wrong. If something is in the wrong place, say where it should be instead. It can read the scene back, so a correction is cheap.