What an agent can do

An agent works through tools, each one a single job with its own checks. The tools refuse what the engine would not load, so an agent’s mistake is caught when it makes it, not when the game runs. The sample games in the engine’s repository were built this way.

The project and its assets

• Create and open projects, and read and change the project settings.
• Import files, with the import dialog’s options, and cook.
• Create assets (anything the editor’s File > New menu makes), and read and edit a data asset’s content: an input map’s actions and bindings, a material, a sound cue.
• Look up the engine’s types, and any component’s fields with their defaults and ranges.
• Find what uses an asset before deleting it, and check the whole project for broken references.

Scenes

An agent writes a scene, or a prefab, as XML and has the engine check it before saving: it loads it exactly as the game would and refuses it, with the reasons, if anything is wrong. The servers give it the format, generated from the engine itself, with an example to copy.

In the editor, an agent can also build in an open scene page one edit at a time: create entities, add components, set their properties, spawn prefabs and add script behaviors. You can undo each change on its own, and nothing is saved until you (or the agent) save the page.

It can also select entities, move the editor camera, frame what it built and take a screenshot of the viewport to see the result, and bake a navigation zone.

Scripts

An agent reads the script API as the engine binds it, for Luau or AngelScript, rather than from memory. It creates a script, writes it, compiles it to check it, and cooks it.

Shaders and GUI

An agent creates a custom shader, writes it, and checks it before cooking it: every variant of it is compiled, and each error comes back with its file, line and column. Then it puts materials on it.

It checks the game’s GUI the same way: a markup document or a style sheet, with each problem and its line, before it is saved.

Playing and testing

In the editor, an agent can play the game in the Game tab and test it:

• Start the game, and take screenshots of it.
• Play it with input: keys, the mouse and gamepads, on a timeline, through the project’s input map as a player’s would.
• Watch values while it plays (an entity’s position, a behavior’s field, the game script’s score) and stop early on a condition, such as the player falling off the level.
• Run several Game tabs at once, a host and a client for a networked game.

That is how a playtest turns into numbers an agent can check, and screenshots you can look at.

Working the editor

In the editor, an agent can also run the editor’s menu commands, open and close pages, rearrange the panels, and take a screenshot of the whole editor window. A command that would open a dialog has the dialog cancelled, since nobody is there to answer it. The agent can also find, click, type into and scroll the editor’s own controls as you would, to check a page or a dialog.

Exporting

An agent lists and sets up export presets and exports the game, as Project > Export… does.

Diagnosing

An agent reads the engine’s log, from a marker it writes before trying something, and the engine’s list of known issues, so it can tell a known problem from a new one.

In the editor, an agent can profile the next few seconds: it gets the frame times, the scopes and GPU passes that took longest, the average draws, passes and GPU memory, and the capture files to hand you (see The profiler).

The full list of tools, and how to use each, is in the guide every server carries: docs://McpGuide.md.