FlaxMCP-Live
FlaxMCP-Live
MCP (Model Context Protocol) server for Flax Engine projects, built with .NET 10 / C# on the official ModelContextProtocol C# SDK. An AI client uses it to work through the live editor without manual steps: check, compile, play, control the game, read the result.
FlaxMCP-Live is an independent fork of eXoz00rd/FlaxMCP by Sebastian Rokicki (MIT).
It keeps all upstream tools and adds 16 tools. The code keeps the upstream names (FlaxMcp namespaces, the
FlaxMcpBridge plugin). Thus you can merge upstream changes. See Staying in sync with upstream.
Why "Live": the added tools work on the running editor and the running game, not on files:
The bridge stays connected when the editor reloads the scripts.
A client waits for the editor's events. It does not poll.
A client calls commands in the game while the game plays.
The name tells you that this fork is about this live loop.
Status: 1.1 (see CHANGELOG). You install from source. There is no NuGet package yet.
What you get
From upstream FlaxMCP | Added in FlaxMCP-Live |
Offline project, content and scene inspection | A bridge host that survives script reloads |
Headless script compilation, game builds, structured logs | Long operations as jobs with progress notifications |
Live editor tools: actors, selection, transforms, colliders, static models, save, play mode, screenshots | Editor events and waiting: no polling, no sleeps |
Material creation and material instance parameters | Game commands: your game registers named commands, the client calls them |
An optional gated C# execution tool | Compile checks in under a second, also while the editor plays |
Read-only mode and toolset selection | Read and write any member of an actor or script. Find actors by name, type or script |
An agent skill that teaches an AI agent to use the server ( | |
Large-world engine support (double-precision vectors), Flax 1.13 |
Use an IDE-integrated MCP, such as Rider, for C# navigation and refactoring. FlaxMCP-Live does the engine operations, and it reads the editor state that a code model cannot see.
Related MCP server: tuanjie-mcp
An unattended loop
The main use: an AI client changes game code and checks the result in the running game. No step is manual.
build_check_scripts {} # compile errors in under a second, as SARIF
editor_compile {} # reload scripts; returns when the editor has settled
editor_open_scene { "path": "Scenes/Main.scene" }
editor_play_mode { "action": "start" }
editor_wait_for { "kind": "play_begin", "timeoutSeconds": 60 }
game_command { "name": "spawn", "args": "wave=1" } # a command your game registered
editor_wait_for { "kind": "log", "textContains": "wave cleared", "timeoutSeconds": 300 }
editor_get_member { "actorId": "…", "member": "Score", "scriptType": "PlayerController" }
editor_play_mode { "action": "stop" }
logs_errors {} # anything that went wrong on the wayEach step returns when its work is done. A script reload between the steps does not stop the connection.
Tools
The default configuration exposes 57 tools across ten toolsets. server is always enabled; every other toolset can be
selected with FLAX_TOOLSETS. Tools added in FlaxMCP-Live are in bold.
Toolset | Tools |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
editor_execute_csharp and editor_invoke_method are additional editor tools that are absent by default. They appear
only when FLAX_ALLOW_CODE_EXECUTION=true and read-only mode is disabled.
Upstream polls a build with build_status and build_result. FlaxMCP-Live replaces these two tools with the job tools.
The job tools also run compiles, play mode changes and scene loads.
Offline inspection
project_info reads the .flaxproj; project_targets parses declarations from *.Build.cs; and project_settings
returns structured settings assets. The content tools maintain an in-memory index under Content/, including GUID and
type metadata read from binary asset headers (Storage format version 9, Flax 1.12 and 1.13). Unrecognized binary assets
remain searchable by path without guessed metadata.
The scene tools parse .scene and .prefab files without starting the editor. Actor trees use ParentID relationships,
attach scripts to their owners, and report when response limits truncate a result.
Builds, checks and logs
build_generate_projects, build_compile_scripts, and build_clear_cache run the editor headlessly and wait for the
operation. Script compilation extracts structured diagnostics rather than returning a raw log.
build_check_scripts compiles the script modules outside the editor, with the compiler arguments Flax.Build last
wrote (Cache/Intermediate/<EditorTarget>/<Platform>/<Arch>/<Config>/<Module>.CSharp.response) and the modules' current
files. It uses the .NET SDK's compiler server and writes to a scratch folder. It returns the errors as SARIF, with
file, line, column and code, in less than a second. It also works while the editor is open or in play mode.
editor_compile runs this check first. Only a clean check continues to the editor.
Build tools refuse to start a second editor process while the same project has a live editor session. Close the GUI editor
before using them. logs_tail and logs_errors only read the newest project log and remain available while it is running.
The diagnose_build_failure prompt combines build_compile_scripts with logs_errors to distinguish compiler failures
from engine or project-configuration errors.
Jobs
build_game can take minutes. Thus it starts a background job and returns the job's handle immediately:
Call
build_gamewith a preset and target, for exampleDevelopmentandWindows.Call
job_waitwith the job ID. It sends progress notifications. It returns the state when the job ends or when the wait time ends.job_statusreads the state and does not wait.The
resultof an ended job is the build outcome. A failed job has anerror.
editor_job_start runs long editor operations in the same way: compile, play_start, play_stop, play_pause,
play_resume or open_scene. It returns immediately. The editor runs one job at a time.
Live editor bridge
The editor tools communicate with the companion plugin over a local named pipe. flax_status reports whether the
configured project has a reachable, protocol-compatible session. Live calls fail clearly when the editor or plugin is not
running, or when the editor process that opened the session has exited.
Live scene reads include unsaved state. Write tools change selection and transforms, save modified scenes and assets, and
control play mode with start, pause, resume, or stop. editor_screenshot writes a PNG of the visible scene viewport;
it requires a GUI editor with a rendered viewport and does not work headlessly. Its destination directory must exist.
editor_camera_screenshot renders a camera into its own render target instead: the given Camera actor, the main camera
in play mode, or the editor viewport's view. It does not read an editor window, so it works with the editor covered,
small or minimised, at any size from 16 to 8192 pixels per side. It shows the 3D scene with the game's post effects,
without editor or screen-space UI.
It survives script reloads
When a script changes, the editor reloads its plugins. A usual plugin loses its pipe at that time. In FlaxMCP-Live, a
bridge host (src/FlaxMcpBridge/Host) owns the pipe:
The plugin compiles the host one time for each editor process, into the Default load context. Thus a reload does not stop the host.
Each reloaded plugin attaches to the host again.
A request that arrives during a reload waits until the reload ends.
When a reload interrupts a request, the host answers
interrupted_by_reload. The server sends read-only requests again.A changed host takes control of the pipe from the old host.
editor_host_status reports the host, the plugin generation, the editor's memory and how many old plugin load
contexts are still alive. Call it first when the memory increases over many reloads.
Events and waiting
The host records the editor's events in a ring buffer: managed log lines, compiles, reloads, play mode changes, scene
loads and saves. editor_events reads the events after a sequence number. editor_wait_for waits until an
event of a given kind arrives, for example play_begin, reload_end or log. It can also wait for an event with a
given text. Thus a client waits for the event that it needs and does not sleep or poll. editor_compile waits until
the editor has reloaded and is stable. The editor also compiles changed sources without a request.
Game commands
A game registers named commands. A client lists them with game_commands and calls them with game_command. The
registration needs the FlaxMcpBridge module as a dependency of the game module
(options.PrivateDependencies.Add("FlaxMcpBridge") in the .Build.cs file).
using FlaxMcpBridge;
var registration = GameCommands.Register(
"spawn", "Spawns a wave. Argument: wave=<n>.", arg => SpawnWave(arg));
// Dispose the registration when the script is destroyed.The handler gets the argument string and returns the result text. The tool shows the type that declares the handler as the owner of the command.
Members, actors and snippets
editor_find_actors finds actors by name, type or script type. editor_get_member and editor_set_member
read and write a member path of an actor or of one of its scripts, for example Settings.Speed. editor_add_script
attaches a script. editor_open_scene opens a scene. The server checks each tool result against its output schema.
editor_execute_csharp compiles a snippet in the bridge host and runs it on the editor main thread. The compiler stays
loaded across reloads. editor_invoke_method calls one method by name. Both tools need FLAX_ALLOW_CODE_EXECUTION.
Large worlds and Flax 1.13
The bridge reads actor translations and vectors as double precision. It builds against engines with large worlds enabled. The minimum engine version is 1.13.7012.
Requirements
.NET 10 SDK
Flax Engine 1.13.7012 or newer installed locally
a Flax project (
.flaxproj)the companion plugin installed in that project for live editor tools
Setup from source
1. Get and validate the server
git clone https://github.com/meet-brad-ch/FlaxMCP-Live.git
cd FlaxMCP-Live
dotnet build FlaxMcp.slnx
dotnet test FlaxMcp.slnx
dotnet format --verify-no-changes2. Install the editor bridge
Add the bridge project to the consumer project's References array, using an absolute path or one relative to the
consumer .flaxproj:
{
"References": [
{ "Name": "$(EnginePath)/Flax.flaxproj" },
{ "Name": "../FlaxMCP-Live/src/FlaxMcpBridge/FlaxMcpBridge.flaxproj" }
]
}Keep existing references and adjust only the bridge path. Flax discovers the EditorPlugin from this reference; no
consumer-side PrivateDependencies or Modules.Add entry is required. Start or reload the GUI editor and call
flax_status to confirm connected: true.
3. Configure an MCP client
Publish the server with tools/publish.sh (it writes .publish/FlaxMcp.exe, which starts in under a second and does
not lock bin/ while you build) and use the executable as the process target. dotnet run --project src/FlaxMcp works
too. This JSON shape works for clients that accept an mcpServers map, including Claude Code configuration files:
{
"mcpServers": {
"flax": {
"command": "D:/Tools/FlaxMCP-Live/.publish/FlaxMcp.exe",
"env": {
"FLAX_PROJECT_PATH": "D:/Projects/YourFlaxProject"
}
}
}
}In Rider's MCP server settings, create a stdio server with the same command and environment variables.
tools/mcp_roundtrip.py runs tool calls against a server build over stdio from the command line. Prefer absolute paths because GUI clients do not necessarily inherit the shell working directory.
Call server_info, project_info, and flax_status as a basic verification.
4. Give your AI agent the usage skill
The folder skills/flaxmcp-live is an agent skill. It tells an AI agent how to use the server:
the order of the calls, the two kinds of IDs, the traps of the live editor, worked workflows and all 59 tools with their
parameters. For Claude Code, copy the folder to ~/.claude/skills/ (for all your projects) or to .claude/skills/ in
your Flax project. Other agents that read SKILL.md files can use the same folder.
After a server change, make the tool reference again:
python skills/flaxmcp-live/scripts/dump_tools.py --project "D:/Projects/YourFlaxProject"Configuration
Variable | Required | Description |
| yes | Path to a |
| no | Flax Engine root. When omitted, uses the Flax Launcher's |
| no | Editor binary configuration: |
| no | Comma-separated selection from |
| no |
|
| no | Bridge mode placeholder; defaults to |
| no | Enables |
| no | Minimum server log level written to stderr; defaults to |
Unknown toolset names fail at startup and list valid values. With FLAX_READ_ONLY=true, the remaining tools are
server_info, flax_status, the project and scene tools, build_check_scripts, content_search, content_asset_info,
content_resolve_guid, content_material_details, both log tools, editor_scene_graph, editor_get_selection,
editor_actor_details, editor_static_model_details, editor_box_collider_details, editor_host_status,
editor_find_actors, editor_get_member, editor_events, editor_wait_for, job_status, job_wait, and
game_commands.
Security
The bridge accepts local named-pipe connections and records discovery data under
%APPDATA%/FlaxMcp/sessions; it does not require network credentials.Build and editor write tools run with the current user's filesystem and process permissions. Use
FLAX_READ_ONLY=truefor inspection-only clients.editor_execute_csharpcompiles and runs arbitrary C# on the editor main thread with the Flax Editor process's full machine permissions, including access to files, processes, credentials, and the network. Enable it only for trusted clients and prompts.
Troubleshooting
flax_status reports connected: false
Confirm the configured project matches the project open in Flax, the bridge reference is present in its .flaxproj, and
the editor has finished compiling scripts. Reload scripts or restart the editor after adding the plugin. Check the latest
project log for [FlaxMcpBridge] Pipe server started or a plugin compilation error.
Protocol mismatch
The server and editor plugin came from incompatible revisions. Update both from the same checkout, let Flax recompile the plugin, and reload scripts. A mismatch is rejected explicitly rather than sent through an incompatible protocol.
A build says the editor is already running
Headless build operations intentionally refuse to race a GUI editor using the same project and Cache/ directory. Close
that editor session normally, then retry. Log-reading and live-editor tools do not require this step.
Screenshot capture fails
Open a scene in the GUI editor and ensure its scene viewport is visible. Capture requires a rendered viewport, cannot run
headlessly, only accepts a .png path, and does not create the destination directory.
Staying in sync with upstream
git fetch upstream --no-tags
git switch -c sync-upstream main
git merge upstream/mainThe code of this fork is in files that upstream does not have. A few hook lines connect it to upstream code. A merge has a conflict only where upstream changes one of these lines. See MAINTAINING.
Versions
FlaxMCP-Live uses Semantic Versioning. The CHANGELOG lists each release. MAINTAINING gives the release steps. The server and the bridge plugin must come from the same release.
Contributing
Contributing Guide — branch flow, commits, code style, CI
Maintaining — versions, releases, upstream sync, seams
Task Conventions — writing issues and definitions of done
Agent Instructions — single source of truth for AI tools working on this repository
License
MIT. Copyright (c) 2026 Sebastian Rokicki and Brad Chamberlain.
Available Tools
57 toolsbuild_check_scriptsARead-only
Compiles the project's script modules, and those of the projects it references, outside the editor into a scratch folder. It uses the compiler arguments that Flax.Build last used and the current files of the modules. Returns passed, failed or unavailable (never built: Reason tells why), with structured errors and warnings (file, line, column, code) and the outcome of each module. It works while the editor is open, also during play mode. It changes nothing in the project. Use it to find compile errors fast. It does not load the change into the editor: for that, use editor_compile.
Inputs: no named parameters. Returns: errors, reason, status, modules, +2 more
build_clear_cacheB
Runs FlaxEditor.exe -clearcache, and optionally -clearcooker too, to clear build caches.
Inputs: alsoClearCooker. Returns: errors, exitCode, timedOut, succeeded, +1 more
build_compile_scriptsA
Compiles the game scripts in a separate headless Flax Editor process, with a time limit of 2 minutes. Returns structured compiler errors (file, line, code, message) from the engine log. The tool fails when a Flax Editor is open on the project. With the editor open, use build_check_scripts to find errors, or editor_compile to compile and reload.
Inputs: no named parameters. Returns: errors, exitCode, timedOut, succeeded, +1 more
build_gameA
Starts a game build (-build ., e.g. preset 'Development', target 'Windows') in the background and returns its job at once -- a real build can take minutes. Follow it with job_status or job_wait; the job's result is the build outcome.
Inputs: preset (required), target (required). Returns: kind, jobId, startedUtc
build_generate_projectsA
Runs FlaxEditor.exe -genprojectfiles to regenerate IDE project/solution files.
Inputs: no named parameters. Returns: errors, exitCode, timedOut, succeeded, +1 more
content_asset_infoBRead-only
Returns metadata (Id, TypeName, RelativePath, Extension) for the content asset with the given GUID.
Inputs: id (required). Returns: id, typeName, extension, relativePath
content_create_materialA
Creates a surface Material asset through the live Flax Editor and saves it. relativePath is relative to Content/ and ends in .flax. The tool does not overwrite: it fails when an asset exists at that path. It creates missing folders. The editor does not record an Undo step. Texture ids are asset GUIDs of 32 hex digits: get them from content_search. normalTextureId must be a texture that is imported as a normal map. For glass, water or film, use content_create_material_transparent. For a variant of an existing material, use content_create_material_instance.
Inputs: metallic (required), baseColor (required), roughness (required), relativePath (required), +4 more. Returns: metallic, uvTiling, baseColor, roughness, +7 more
content_create_material_instanceA
Creates a MaterialInstance asset from a live surface material and applies validated parameter overrides atomically.
Inputs: parameters (required), relativePath (required), baseMaterialId (required). Returns: parameters, mainThreadId, baseMaterialId, baseMaterialPath, +2 more
content_create_material_transparentA
Creates a transparent surface Material (blend mode Transparent, Lit) through the live Flax Editor, for glass, water or film. Opacity 0 is fully clear. Refraction is the material's Refraction input: 1 bends nothing. Flax applies it as a strong screen distortion: 1.03 already shrinks objects behind a bottle-sized surface to about 40 % of their width, as through thick glass. Use 1.0 for thin glass with something inside (a bottle with liquid), and values above 1 only for a lens effect. The material traces screen-space reflections. Its four values are public parameters named BaseColor, Opacity, Roughness and Refraction, so content_create_material_instance makes variants (a tint, frosted or thicker glass, water) of one material. Paths are relative to Content/ and must end in .flax. No asset may exist at the path.
Inputs: opacity (required), baseColor (required), roughness (required), relativePath (required), +1 more. Returns: opacity, baseColor, blendMode, roughness, +5 more
content_material_detailsARead-only
Returns typed values, texture references, UV tiling, and exposed parameters for a live surface Material asset.
Inputs: materialId (required). Returns: metallic, uvTiling, baseColor, roughness, +7 more
content_resolve_guidBRead-only
Resolves a content asset GUID to its path relative to Content/.
Inputs: id (required). Returns: result
content_searchBRead-only
Searches the Content/ index by partial path match, TypeName, and/or extension. Id/TypeName are null for files whose format isn't recognized or a .flax header that doesn't match the reverse-engineered layout (verified against Flax 1.12 and 1.13).
Inputs: query, typeName, extension. Returns: result
content_set_material_instance_parameterB
Sets one validated parameter override on an existing MaterialInstance and saves the asset.
Inputs: value (required), parameterName (required), materialInstanceId (required). Returns: parameters, mainThreadId, baseMaterialId, baseMaterialPath, +2 more
editor_actor_detailsARead-only
Returns live identity, hierarchy, activation, layer, tags, world/local transforms, and scripts for one actor loaded in the Flax Editor.
Inputs: actorId (required). Returns: id, name, tags, layer, +10 more
editor_add_scriptA
Adds a script of a type to an actor (nothing when it has one already) and, in edit mode, marks the scene edited so editor_save keeps it. The type is resolved by full or short name in the loaded assemblies.
Inputs: actorId (required), scriptType (required), orderInParent. Returns: added, actorId, scripts, scriptId, +3 more
editor_box_collider_detailsARead-only
Returns the local size, center, trigger mode, and actor details for a loaded BoxCollider.
Inputs: actorId (required). Returns: size, actor, center, isTrigger, +1 more
editor_camera_screenshotA
Renders a camera into its own render target and saves a PNG. It does not read an editor window, so it works with the editor covered, small or minimised, in play mode and in edit mode. Camera: the given Camera actor. Without one: the main camera in play mode, else the editor viewport's view. The picture shows the 3D scene with the game's post effects, without editor or screen-space UI. Not available in headless mode. Replaces an existing file. Read the PNG to see it.
Inputs: path (required), width, height, cameraId, +1 more. Returns: path, bytes, width, camera, +2 more
editor_compileA
Compiles the project's scripts and returns when the editor has reloaded and settled. First, the tool compiles the scripts outside the editor with the compiler arguments that Flax.Build last used (build_check_scripts). Errors come back at once, structured (file, line, column, code), and the editor does not change. After a clean check, the tool stops play mode and the editor compiles. The outcome is reloaded, unchanged or failed (build tool lines in BuildErrors). Check tells how the check went: passed, failed, or unavailable with the reason. Use this tool when the editor is open. With no editor, use build_compile_scripts. To find errors without a change in the editor, use build_check_scripts.
Inputs: no named parameters. Returns: check, errors, outcome, reloads, +2 more
editor_create_actorB
Creates an allowlisted EmptyActor or StaticModel in a loaded scene and returns its live details.
Inputs: name (required), scale (required), sceneId (required), parentId (required), +3 more. Returns: id, name, tags, layer, +10 more
editor_create_box_colliderB
Creates a BoxCollider under a loaded parent actor and returns its effective properties.
Inputs: name (required), size (required), center (required), parentId (required), +1 more. Returns: size, actor, center, isTrigger, +1 more
editor_delete_actorA
Deletes a loaded actor through the editor Undo/Redo history. Set deleteDescendants to true to explicitly delete its complete hierarchy; false rejects actors with children.
Inputs: actorId (required), deleteDescendants (required). Returns: actorId, mainThreadId, deletedActorIds, deletedDescendants
editor_duplicate_actorA
Duplicates a loaded actor, with its children and scripts, into a loaded scene or under a loaded parent actor. Returns the live details of the duplicate. Set exactly one of sceneId and parentId, and set the other to null. name is the name of the duplicate. Its children keep their names. translation, orientation and scale set the world transform of the duplicate. The source actor does not change. The editor records an Undo step. The scene stays unsaved until editor_save. To make a new actor of a type, use editor_create_actor. To move an actor to a different parent, use editor_reparent_actor.
Inputs: name (required), scale (required), actorId (required), sceneId (required), +3 more. Returns: id, name, tags, layer, +10 more
editor_eventsARead-only
Returns the editor's recorded events after a sequence number, oldest first. Kinds: log (managed log lines only; the engine's native lines such as compiler output stay in the log file), exception, compile_begin, compile_succeeded, compile_failed, reload_begin, reload_end, play_begin, play_end, scene_loaded, scene_load_error, scene_saved, scene_save_error, scene_unloaded. The bridge host keeps the last 4096 events across script reloads; Truncated is true when some after sinceSeq were overwritten. A new HostStartedUtc means the editor restarted and the sequence began again.
Inputs: kinds, limit, sinceSeq, waitSeconds. Returns: events, lastSeq, oldestSeq, truncated, +1 more
editor_find_actorsARead-only
Finds actors in the scenes that are open in the running editor (the play-time scene during play), with the unsaved changes. The filters are name, actor type and script type. All are optional, and they combine. Types match by full or short name. Returns id, name, type, path from the scene and the types of the scripts. Truncated is true when more than the limit matched. For a saved .scene or .prefab file without the editor, use scene_find_actor. For the full tree, use editor_scene_graph.
Inputs: limit, actorType, scriptType, nameContains. Returns: actors, truncated, mainThreadId
editor_get_memberARead-only
Reads a field or property of an actor, or of one of its scripts, by a dotted path (e.g. Clock.Steps). Private members count. Unknown names list the members that exist.
Inputs: member (required), actorId (required), scriptType. Returns: value, member, targetId, typeName, +3 more
editor_get_selectionARead-only
Returns the actors currently selected in the live Flax Editor.
Inputs: no named parameters. Returns: selected, mainThreadId
editor_host_statusARead-only
Returns the state of the bridge host, the pipe server that outlives script reloads: its version and start time, the attached plugin generation, attach and detach counts, the editor's memory and garbage collections, and how many old plugin load contexts are still alive (reloads that leak). collect=true runs a full garbage collection first so that count is a measurement; it takes long on a large heap.
Inputs: collect. Returns: attached, accepting, collected, generation, +12 more
editor_job_startA
Starts a long editor operation as a job and returns at once. The kinds are compile (compile the scripts and wait until the editor has reloaded and settled), play_start, play_stop, play_pause, play_resume and open_scene (path). Editor jobs run one at a time. A second job while one runs fails with job_conflict, which names the running job. Follow the job with job_wait or job_status. Its result is the result of editor_compile, editor_play_mode or editor_open_scene. Use this tool instead of those tools when the client must not wait, or when it does other work and then checks the job.
Inputs: kind (required), path. Returns: kind, jobId, startedUtc
editor_modify_actorA
Replaces an existing live actor's world transform and returns its updated details. Use editor_actor_details first to preserve transform values that should not change.
Inputs: scale (required), actorId (required), orientation (required), translation (required). Returns: id, name, tags, layer, +10 more
editor_open_sceneA
Opens a scene in the live Flax Editor and returns when it has loaded. The path is absolute or relative to the project's Content folder (for example Scenes/Main.scene). Refused during play mode.
Inputs: path (required). Returns: scenes, sceneId, sceneName, mainThreadId
editor_play_modeA
Controls play mode in the live Flax Editor. Action must be start, stop, pause, or resume. Returns when the editor has reached the requested state (up to 30 seconds, so a heavy scene can load).
Inputs: action (required). Returns: isPaused, isPlayMode, mainThreadId, requestedAction
editor_rename_actorA
Renames a loaded actor through the editor Undo/Redo history and returns its updated details.
Inputs: name (required), actorId (required). Returns: id, name, tags, layer, +10 more
editor_reparent_actorA
Moves a loaded actor to another loaded parent or to a loaded scene root through Undo/Redo history. Set exactly one of sceneId or parentId and explicitly choose whether to preserve the world transform.
Inputs: actorId (required), sceneId (required), parentId (required), preserveWorldTransform (required). Returns: id, name, tags, layer, +10 more
editor_saveA
Saves every open scene (including changes made through the API, which the editor does not mark as modified) and all modified content assets in the live Flax Editor. Refused during play mode: a save then would write the play-time scene, with every actor scripts created at run time.
Inputs: no named parameters. Returns: saved, savedScenes, mainThreadId
editor_scene_graphARead-only
Returns the live actor tree of every scene that is open in the running Flax Editor, with the unsaved changes. Truncated is true when the tree has more than 500 nodes or 32 levels. For a saved .scene or .prefab file without the editor, use scene_outline. To find actors by name or type, use editor_find_actors.
Inputs: no named parameters. Returns: scenes, truncated, mainThreadId
editor_screenshotA
Captures the Scene viewport of the running Flax Editor to a PNG file. The Scene tab must be visible: the capture fails when another tab covers it. The output folder must exist. The capture is not available in headless mode. To render from a camera without the Scene tab, use editor_camera_screenshot.
Inputs: path (required). Returns: path, bytes
editor_set_box_colliderB
Updates a loaded BoxCollider's local size, center, and trigger mode through Undo/Redo history.
Inputs: size (required), center (required), actorId (required), isTrigger (required). Returns: size, actor, center, isTrigger, +1 more
editor_set_memberA
Writes a field or property of an actor or of one of its scripts by a dotted path; a struct on the way is written back. The value is JSON in the member's shape (a number, true, "text", an enum name, {"X":1,"Y":2,"Z":3}). In edit mode it goes through the editor's undo and marks the scene edited (editor_save keeps it); in play mode it lasts until play ends. Returns the value read back.
Inputs: value (required), member (required), actorId (required), scriptType. Returns: value, member, targetId, typeName, +3 more
editor_set_selectionA
Replaces the live Flax Editor actor selection with the actors identified by GUID. Pass an empty list to clear the selection.
Inputs: actorIds (required). Returns: selected, mainThreadId
editor_set_static_modelA
Assigns an existing FlaxEngine.Model asset to a loaded StaticModel actor through Undo/Redo history. The bridge validates that modelId resolves to a compatible model before changing the scene.
Inputs: actorId (required), modelId (required). Returns: actor, modelId, modelPath, mainThreadId, +1 more
editor_set_static_model_materialA
Assigns an existing FlaxEngine.MaterialBase asset to one slot of a loaded StaticModel through Undo/Redo history. The bridge validates the actor, slot, and material before changing the scene.
Inputs: actorId (required), slotIndex (required), materialId (required). Returns: actor, slotIndex, materialId, mainThreadId, +1 more
editor_static_model_detailsARead-only
Returns the assigned model reference and live actor details for a loaded StaticModel actor.
Inputs: actorId (required). Returns: actor, modelId, modelPath, mainThreadId, +1 more
editor_wait_forARead-only
Waits for the first editor event of a kind (see editor_events), optionally with a text, and returns it. Without sinceSeq it waits for an event after the call; with it, an event already recorded after that number counts. A timeout is a result (TimedOut true), not an error. Example: start play with editor_play_mode, then editor_wait_for kind=log textContains="[Test]" to read a game's answer.
Inputs: kind (required), sinceSeq, textContains, timeoutSeconds. Returns: event, lastSeq, matched, seconds, +1 more
flax_statusARead-only
Reports whether the configured project has a reachable Flax Editor bridge and returns its session metadata.
Inputs: no named parameters. Returns: error, connected, generation, startedUtc, +3 more
game_commandA
Runs a registered game command on the editor's main thread and returns its text result. Errors: unknown_command (lists the registered names), command_failed (the handler's exception type and message).
Inputs: name (required), args. Returns: name, result, isPlayMode, mainThreadId, +1 more
game_commandsARead-only
Lists the commands the game registered with the bridge (FlaxMcpBridge.GameCommands.Register): name, description and the type that registered it. Game scripts usually register while enabled, so the list in play mode can differ from the one in edit mode.
Inputs: no named parameters. Returns: commands
job_statusARead-only
Returns a job's state: running, succeeded (with its result), failed or canceled (with the reason), and its latest progress message. Jobs come from editor_job_start, build_game, and the editor tools that run as jobs.
Inputs: jobId (required). Returns: kind, error, jobId, result, +4 more
job_waitARead-only
Waits for a job to end, up to the timeout, sending its progress messages as progress notifications, and returns its state. A timeout is a result (Status running), not an error.
Inputs: jobId (required), timeoutSeconds. Returns: kind, error, jobId, result, +4 more
logs_errorsARead-only
Extracts lines tagged [Error] or [Warning] from the project's most recent Logs/*.txt file, without running the editor.
Inputs: no named parameters. Returns: result
logs_tailARead-only
Returns the last N lines (default 200) of the project's most recent Logs/*.txt file, without running the editor.
Inputs: lines. Returns: lines, fileName
project_infoARead-only
Reads the .flaxproj file: name, version, targets, references, and default scene.
Inputs: no named parameters. Returns: name, version, gameTarget, references, +3 more
project_settingsARead-only
Reads Content/.json and Content/Settings/.json settings assets (Game, Graphics, Input, Physics, ...) as structured JSON.
Inputs: no named parameters. Returns: result
project_targetsBRead-only
Parses the GameTarget/EditorTarget *.Build.cs files referenced from the .flaxproj: target class names and referenced modules.
Inputs: no named parameters. Returns: gameTarget, editorTarget
scene_find_actorARead-only
Searches the actors of a saved .scene or .prefab file on disk. Name matches a part of the actor name, TypeName matches the full type name, and both ignore case. The tool does not need the editor and does not see unsaved changes. It returns the first 100 matches. For the scenes in the running editor, use editor_find_actors.
Inputs: path (required), name, typeName. Returns: result
scene_listBRead-only
Lists scenes (.scene) and prefabs (.prefab) in the project's Content/ directory.
Inputs: no named parameters. Returns: result
scene_outlineARead-only
Reads the actor tree of a saved .scene or .prefab file on disk. The tree comes from the ParentID links, not from the file order. The scripts of an actor are in its Scripts list, not in its child nodes. Truncated is true when the tool reached the depth or node limit. The tool does not see unsaved changes. For the live tree in the running editor, use editor_scene_graph.
Inputs: path (required). Returns: id, roots, truncated, engineBuild
server_infoARead-only
Returns the FlaxMcp server name and version.
Inputs: no named parameters. Returns: name, version
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 57 tools
Descriptions go to unusual lengths to route callers between the disk-based (scene_outline, scene_find_actor, content_search) and live-editor (editor_scene_graph, editor_find_actors) variants, which prevents most misselection. However, the set has genuine redundancy: four compile paths (build_check_scripts, build_compile_scripts, editor_compile, editor_job_start kind=compile), play mode via both editor_play_mode and editor_job_start, and job wrappers that shadow the direct tools. An agent must read long descriptions to pick correctly in several places.
Names are grouped by domain prefix (content_, scene_, editor_, build_, logs_, job_, project_) and all use snake_case, which is readable. But the verb/noun convention is mixed within prefixes: editor_get_member/editor_set_member/editor_set_selection use verbs while editor_actor_details/editor_scene_graph/editor_box_collider_details use nouns, and a few outliers (server_info, flax_status, job_wait vs editor_wait_for) break the pattern.
At 57 tools this is far past the comfortable 3-15 band and well into 25+ territory, even for a broad engine bridge spanning content, scenes, actors, build, logs, jobs, and screenshots. Several tools are near-duplicates (four compile routes, two screenshot tools, job wrappers around direct tools) and could be folded into parameterized tools to shrink the surface considerably.
Coverage is deep: content asset resolution/search/material creation, disk and live scene inspection, a solid actor lifecycle (create, duplicate, rename, reparent, delete, transform, scripts, members, static model, box collider), build/job/log infrastructure, screenshots, and event waiting. Notable gaps remain — no asset delete/move/rename, no scene or prefab creation, only EmptyActor/StaticModel/BoxCollider creatable — but none break core workflows.
Maintenance
Related MCP Connectors
Control Unreal Engine to browse assets, import content, and manage levels and sequences. Automate…
Drive a live Cinevva game session: edit game files, import CC0 assets, preview changes.
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to control Unreal E…
Build and inspect browser-based 3D games: projects, scenes, Lua scripts, assets and publishing.
Related MCP Servers
- FlicenseNot gradedqualityCmaintenanceBridges OpenCode to Unreal Engine 5 editor via a local TCP connection, enabling interaction with the editor such as querying project structure, managing assets and actors, and generating code.-
- FlicenseNot gradedqualityBmaintenanceEnables AI tools to connect to and control Unity/Tuanjie editors via the Codely Bridge TCP server, supporting project management, scene manipulation, and console reading.3-
- AlicenseBqualityCmaintenanceEnables AI clients to author and inspect Godot 4 projects by editing .tscn scenes and .gd scripts directly on disk, running headless project checks, and optionally driving a live editor bridge for real-time scene editing.2015 npmMIT
- FlicenseNot gradedqualityCmaintenanceEnables MCP clients such as Codex to drive a Cocos Creator 3.8.8 editor through four tools (status, catalog, execute, observe), covering scene/node/component editing, UI templates and adaptive layout, prefabs, script events, assets and dependency graphs, native animation and Spine, screenshots, and Web build verification. Operations run through a local extension bridge with batching, dry-run pre-checks, and read-back validation.-