Skip to main content
Glama

FlaxMCP-Live

CI License: MIT

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 (skills/flaxmcp-live)

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 way

Each 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

server

server_info, flax_status

project

project_info, project_targets, project_settings

content

content_search, content_asset_info, content_resolve_guid, content_material_details, content_create_material, content_create_material_instance, content_set_material_instance_parameter, content_create_material_transparent

scene

scene_list, scene_outline, scene_find_actor

build

build_check_scripts, build_generate_projects, build_compile_scripts, build_clear_cache, build_game

logs

logs_tail, logs_errors

editor

editor_scene_graph, editor_get_selection, editor_set_selection, editor_actor_details, editor_modify_actor, editor_create_actor, editor_duplicate_actor, editor_rename_actor, editor_reparent_actor, editor_delete_actor, editor_static_model_details, editor_set_static_model, editor_set_static_model_material, editor_box_collider_details, editor_create_box_collider, editor_set_box_collider, editor_save, editor_play_mode, editor_screenshot, editor_camera_screenshot, editor_compile, editor_open_scene, editor_host_status, editor_find_actors, editor_get_member, editor_set_member, editor_add_script

events

editor_events, editor_wait_for

jobs

editor_job_start, job_status, job_wait

game

game_commands, game_command

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:

  1. Call build_game with a preset and target, for example Development and Windows.

  2. Call job_wait with the job ID. It sends progress notifications. It returns the state when the job ends or when the wait time ends. job_status reads the state and does not wait.

  3. The result of an ended job is the build outcome. A failed job has an error.

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-changes

2. 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

FLAX_PROJECT_PATH

yes

Path to a .flaxproj, or a directory containing exactly one top-level .flaxproj

FLAX_ENGINE_PATH

no

Flax Engine root. When omitted, uses the Flax Launcher's %APPDATA%/Flax/Versions.txt registrations

FLAX_EDITOR_CONFIG

no

Editor binary configuration: Development (default), Debug, or Release

FLAX_TOOLSETS

no

Comma-separated selection from project, content, scene, build, logs, editor, events, jobs, and game; server is always included. Omit for all toolsets

FLAX_READ_ONLY

no

true, 1, or yes removes all tools that can alter files or editor state

FLAX_BRIDGE

no

Bridge mode placeholder; defaults to auto. It is parsed but does not currently change connection behavior

FLAX_ALLOW_CODE_EXECUTION

no

Enables editor_execute_csharp and editor_invoke_method only when true and FLAX_READ_ONLY is false

FLAX_LOG_LEVEL

no

Minimum server log level written to stderr; defaults to Warning

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=true for inspection-only clients.

  • editor_execute_csharp compiles 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/main

The 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

License

MIT. Copyright (c) 2026 Sebastian Rokicki and Brad Chamberlain.

Available Tools

57 tools
build_check_scriptsA
Read-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_infoB
Read-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_detailsA
Read-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_guidB
Read-only

Resolves a content asset GUID to its path relative to Content/.

Inputs: id (required). 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_detailsA
Read-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_detailsA
Read-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_eventsA
Read-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_actorsA
Read-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_memberA
Read-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_selectionA
Read-only

Returns the actors currently selected in the live Flax Editor.

Inputs: no named parameters. Returns: selected, mainThreadId

editor_host_statusA
Read-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_graphA
Read-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_detailsA
Read-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_forA
Read-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_statusA
Read-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_commandsA
Read-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_statusA
Read-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_waitA
Read-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_errorsA
Read-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_tailA
Read-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_infoA
Read-only

Reads the .flaxproj file: name, version, targets, references, and default scene.

Inputs: no named parameters. Returns: name, version, gameTarget, references, +3 more

project_settingsA
Read-only

Reads Content/.json and Content/Settings/.json settings assets (Game, Graphics, Input, Physics, ...) as structured JSON.

Inputs: no named parameters. Returns: result

project_targetsB
Read-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_actorA
Read-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_listB
Read-only

Lists scenes (.scene) and prefabs (.prefab) in the project's Content/ directory.

Inputs: no named parameters. Returns: result

scene_outlineA
Read-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_infoA
Read-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

    B3.4/5.0

    Scored across 57 tools

    Disambiguation3/5

    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.

    Naming Consistency3/5

    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.

    Tool Count2/5

    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.

    Completeness4/5

    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

    ActivityMaintained
    ResponsivenessLimited data

    Related MCP Connectors

    Related MCP Servers

    • F
      license
      Not graded
      quality
      C
      maintenance
      Bridges 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.
      -
    • F
      license
      Not graded
      quality
      B
      maintenance
      Enables 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
      -
    • A
      license
      B
      quality
      C
      maintenance
      Enables 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.
      20
      15 npm
      MIT
    • F
      license
      Not graded
      quality
      C
      maintenance
      Enables 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.
      -