Level Actors

List all actors in the current level

Returns every actor currently placed in the active level, including their names, types, and transforms. Use this to get an overview of level contents before performing targeted operations.

  cfa get_actors_in_level

Find actors by name pattern

Searches the current level for actors whose label matches the given pattern. Supports partial matching, so you can find groups of related actors without listing every actor in the level.

  cfa find_actors_by_name --pattern "Light"
  cfa find_actors_by_name --pattern "BP_Conveyor"

Spawn an actor in the level

Creates a new actor instance in the current level at the specified transform. The actor-type defaults to StaticMeshActor but can be any built-in actor class. Use spawn_blueprint_actor for Blueprint-based actors instead. location, rotation and scale must each be three numbers ([x,y,z], {"x":..,"y":..,"z":..}, "x,y,z" or "(X=..,Y=..,Z=..)"; rotation as pitch,yaw,roll). A bad transform, or a static_mesh that is not a StaticMesh asset or is given for another actor type, fails before anything is spawned.

  cfa spawn_actor --name "MyCube" --actor-type "StaticMeshActor" --location "[0,0,100]" --rotation "[0,45,0]" --scale "[2,2,2]"
  cfa spawn_actor --name "FloorPlane" --static-mesh "/Engine/BasicShapes/Plane.Plane" --location "[0,0,0]"

Search available UClasses by name, optionally filtered by a base class

Enumerates loaded UClasses whose name contains the query (case-insensitive), optionally restricted to subclasses of base_class (e.g. 'ActorComponent', 'Actor', or a full path). Excludes abstract (unless include_abstract), deprecated, and transient/generated classes. Returns name, full path, parent, and is_abstract. Use it to discover the exact class name or path to pass to add_component_to_blueprint, spawn_actor_by_class, etc.

  cfa search_classes --query "StaticMesh" --base-class ActorComponent
  cfa search_classes --query Light --base-class Actor --max-results 20

Delete an actor from the level

Removes a placed actor from the current level by its label name. The deletion is immediate and cannot be undone from the CLI, so verify the target with find_actors_by_name first if unsure.

  cfa delete_actor --name "MyCube"

Set actor location/rotation/scale

Updates the world transform of an existing actor in the level. You can set any combination of location, rotation, and scale -- omitted fields are left unchanged. location, rotation and scale must each be three numbers ([x,y,z], {"x":..,"y":..,"z":..}, "x,y,z" or "(X=..,Y=..,Z=..)"; rotation as pitch,yaw,roll); a bad field fails the call and nothing moves.

  cfa set_actor_transform --name "MyCube" --location "[100,200,50]"
  cfa set_actor_transform --name "MyCube" --rotation "[0,90,0]" --scale "[1,1,2]"

Spawn a Blueprint actor instance

Spawns an instance of a Blueprint asset into the current level. Use this instead of spawn_actor when you need to place a Blueprint-based actor with its full component hierarchy and default properties. location, rotation and scale must each be three numbers ([x,y,z], {"x":..,"y":..,"z":..}, "x,y,z" or "(X=..,Y=..,Z=..)"; rotation as pitch,yaw,roll); a bad field fails before anything is spawned.

  cfa spawn_blueprint_actor --blueprint-path "/Game/Blueprints/BP_Miner" --location "[500,0,0]"
  cfa spawn_blueprint_actor --blueprint-path "/Game/Blueprints/BP_ConveyorBelt" --location "[0,0,0]" --rotation "[0,90,0]" --name "Belt_01"

Spawn an actor from a class name

Spawns an actor using a C++ or Blueprint class name with individual float parameters for location and rotation instead of JSON arrays. Useful when you know the exact class name and want to specify coordinates directly.

  cfa spawn_actor_from_class --class-name "PointLight" --location-x 100 --location-y 200 --location-z 300
  cfa spawn_actor_from_class --class-name "AMyCustomActor" --location-z 50 --rotation-yaw 45

Get currently selected viewport actors

Returns the list of actors currently selected in the Unreal Editor viewport. Useful for inspecting or modifying whatever the user has selected in the editor.

  cfa get_selected_actors

Get current level info (world name, actor count)

Returns metadata about the currently loaded world, including the level name, total actor count, and other summary information. Use this to confirm which level is active before performing operations.

  cfa get_world_info

Capture the level viewport or a named editor window to PNG

Captures a screenshot as PNG via Unreal's own FSlateApplication::TakeScreenshot (window) or the level viewport ReadPixels (viewport). Default mode=viewport is the 3D level viewport only, without overlays: stat text and the Niagara Debug HUD appear only with mode=window. mode=window is the full Slate chrome of a window (menus, tabs, Outliner, Details). Pass --window for a title substring from list_editor_windows. To show an asset, call open_asset first, then take_screenshot --mode window --window <editor title>. asset_path on this command is rejected: photographing a docked tab often never paints.

  cfa take_screenshot
  cfa take_screenshot --file-path "C:/Screenshots/level_overview.png" --mode "viewport"
  cfa open_asset --asset-path "/Game/CFATest/BP_Door"
  cfa take_screenshot --mode window --window "CFA_Main" --file-path "C:/Shots/editor.png"

Block until asset and shader compilation finishes

Waits until the editor has no assets and no shader jobs left to compile, then returns. Read any metric only after this returns idle. Material instruction counts, widget layout, lighting budgets and FX cost are all measured against whatever is compiled at that instant, so asking while a compile is still running returns a real number for the wrong thing, with nothing to indicate it. Polls rather than blocking outright, so a timeout is honoured; if it times out it says so and reports what is still outstanding rather than pretending it finished. The CLI waits 30 s longer than timeout_seconds for that report; the editor stops waiting for any reply at 600 s, so keep timeout_seconds at 570 or less.

  cfa wait_for_compilation
  cfa wait_for_compilation --timeout-seconds 300

Read an editor Message Log listing

Returns the messages the editor put in one of its Message Log listings, with counts by severity. These are the same entries the Message Log window shows, and they carry detail that a command's own result does not: which asset failed to load, which actor failed a map check, why a Blueprint compile complained. Filter with --severity error or warning, and cap with --max-results. A log only exists once something has written to it this session, so an unknown name is refused by name rather than returned empty, which would read as no problems.

  cfa read_message_log --log-name PIE
  cfa read_message_log --log-name AssetCheck --severity error
  cfa read_message_log --log-name MapCheck --max-results 20

Run the project's own data validators over its assets

Runs every validator the project itself defines (each UEditorValidatorBase subclass, plus every IsDataValid override) over the assets you point it at, and reports a verdict with the assets that failed and why. This is the project's own definition of correct, not ours, so it catches the rules a studio actually cares about. Scope it with --path, --filter or an explicit --assets list, and cap the work with --max-assets. Assets are loaded to validate them, so a whole-project run is slow; narrow the path while iterating. Verdict is fail if anything is invalid, pass_with_warnings if only warnings were raised, pass otherwise.

  cfa validate_project_assets
  cfa validate_project_assets --path /Game/Characters
  cfa validate_project_assets --filter ABP_ --max-results 50
  cfa validate_project_assets --assets /Game/Hero.Hero --usecase presubmit

Compile a Blueprint and report which nodes failed

Compiles a Blueprint with our own results log attached, then reports the errors and warnings mapped to the nodes that caused them, rather than as a flat wall of text. Each entry names the node and the graph it lives in, so you can go straight to it. Also reports orphaned pins (left behind when a function signature changed) and dangling_exec_chains, the number of exec chains nothing drives, which is the usual sign of a graph that silently never runs (a dead chain counts once, at its head). Compiler notes are reported as note and do not count as warnings. Compiling never saves the asset, even in a project set to save on compile. status distinguishes up_to_date_with_warnings from up_to_date, so a Blueprint that compiles but is dirty does not read as clean.

  cfa validate_blueprint_compile --blueprint-path /Game/BP_Player
  cfa validate_blueprint_compile --blueprint-path /Game/BP_Player --max-results 50

Find static meshes with missing or unusable collision

Checks every static mesh under a path for collision that will not work. A mesh with no simple collision primitives is reported as an error: default traces and sweeps miss it and it cannot block or simulate, though explicit complex traces still hit it. A mesh set to use complex collision as simple is a warning, because it cannot be simulated. Meshes that pass are counted but not listed, so the output stays small on a large project. The check reads the collision counts the engine already publishes to the asset registry, so a whole project sweep loads nothing; loaded_for_inspection reports how many meshes had to be loaded because those tags were missing.

  cfa validate_collision
  cfa validate_collision --path /Game/Environment
  cfa validate_collision --filter SM_Rock --max-results 50

Check a class for silent multiplayer bugs

Statically checks one class for the replication mistakes that cost hours to find at runtime, with no PIE session needed. Reports properties marked Replicated that were never registered in GetLifetimeReplicatedProps, RepNotify properties whose OnRep function does not exist, server RPCs with no validation (a client can call those with any arguments), and reliable multicasts, whose cost scales with connection count. The missing-registration case is a warning rather than an error because a project that auto-registers replicated properties replicates them anyway.

  cfa validate_replication --class-path /Game/BP_Player.BP_Player
  cfa validate_replication --class-path Character

List open editor windows and asset editors

Lists every top-level Slate window the editor has open (title, size, visible, minimized) plus every asset currently being edited and which window holds it. Use this to find the right --window substring for take_screenshot --mode window.

  cfa list_editor_windows

Bring an asset's editor tab to the front

Activates the tab for an already-open asset editor and raises its window, so the user is looking at that asset. Works whether the editor is a floating window or a tab docked in the main frame. Open the asset first with open_asset. Use this when you want the person watching to see the thing you are about to change.

  cfa focus_asset_editor --asset-path "/Game/Anims/ABP_Hero"

List editor tabs you can open, and which are open

Lists every tab the editor can show, open or not, with the id that open_tab and close_tab take: the whole editor's tabs (Output Log, Content Browser, Project Settings, Editor Preferences, Plugins...), the level editor's (Details, Outliner, World Settings...) and each open asset editor's. Each row has id, label, owner (global, level_editor, asset_editor) and open; an open tab adds its window title and whether it is the front tab. --filter matches the id or the label, best matches first; when nothing matches, did_you_mean suggests close spellings. The list stops at --max-results and reports total and truncated.

  cfa list_tabs --filter log
  cfa list_tabs --open-only
  cfa list_tabs --asset-path "/Game/Blueprints/BP_Hero"

Open any editor tab, docked or in its own window

Opens a tab by id (from list_tabs) or by its exact label, the way the Window menu does. --placement auto (default) puts it where Unreal would: its last spot, otherwise a new window. --placement new_window gives it its own floating window; an open tab is closed and reopened there, so its content restarts. --section opens Project Settings or Editor Preferences at one section (name, display name or settings class, as search_project_settings returns), and --tab-id may then be left out. --window-state maximized, minimized or restored sizes the window that holds the tab. For an asset editor's tab pass --asset-path; that editor opens first if it is closed. The result is read back from Slate: window, floating, foreground, window_state and a verdict.

  cfa open_tab --tab-id OutputLog
  cfa open_tab --tab-id "Output Log" --placement new_window --window-state maximized
  cfa open_tab --section "Maps & Modes"
  cfa open_tab --tab-id LevelEditorSelectionDetails
  cfa open_tab --tab-id MyBlueprint --asset-path "/Game/Blueprints/BP_Hero"

Close an open editor tab

Closes an open tab by id, the way its close button does. A locked tab, or one keeping unsaved work, refuses and nothing changes. The tab an asset editor lives in is closed with close_asset instead, which saves or discards its changes; the Level Editor tab stays open. A tab that is not open returns an error saying so; list_tabs --open-only shows what is open.

  cfa close_tab --tab-id OutputLog
  cfa close_tab --tab-id MyBlueprint --asset-path "/Game/Blueprints/BP_Hero"

Maximize, minimize, restore or raise an editor window

Changes an editor window: --state maximized, minimized, restored, or front (restore if minimized, raise, and focus it). Target the window that holds an open tab with --tab-id, a window by a substring of its title with --window (see list_editor_windows, which also lists minimized windows), or pass neither for the main editor window. The state is read back: if the window did not reach it, the command fails and names the state the window is in.

  cfa set_window_state --state maximized
  cfa set_window_state --tab-id OutputLog --state front
  cfa set_window_state --window "BP_Hero" --state minimized

Frame the level viewport on an actor or move the camera

Aims the active level editor perspective viewport. Pass an actor label/name to frame it (like pressing F). Add direction (top/bottom/front/back/left/right/iso) or explicit pitch+yaw to frame it FROM a chosen angle, and fill (0-1) or distance to control how tight the framing is. Or pass an explicit location (and optional rotation) to place the camera directly.

  cfa focus_viewport --actor "ElectricBeamTest"
  cfa focus_viewport --actor "Reactor" --direction "top" --fill 0.8
  cfa focus_viewport --actor "Reactor" --pitch -30 --yaw 120 --distance 1500
  cfa focus_viewport --location "(X=600,Y=-600,Z=400)" --rotation "(P=-25,Y=45,R=0)"

Context-friendly clustered understanding of the level

Summarizes the level so an agent understands it WITHOUT reading a giant per-actor list (scales 10 -> 100k actors). Default returns: content bounds, per-category counts, and one line per detected CLUSTER (actors grouped by mesh, split spatially via grid+union-find connected components), each tagged with an arrangement (grid/ring/line/scattered via PCA + circle-fit + spacing) plus count, instance count, center, size, folder. Also an ASCII density heatmap of the whole level. Drill into a cluster's raw actors with --drill <id> (paginated). Use --export true to write the full flat per-actor JSON to Exports/ (interchange only). label_filter/class_filter scope by label or class-name substring.

  cfa get_scene_map
  cfa get_scene_map --drill 0 --page 0
  cfa get_scene_map --label-filter "Brick_"
  cfa get_scene_map --export=true

Native shape/bounds/pivot of a static mesh asset (before placing)

Inspects a UStaticMesh asset (not a placed actor) so you can plan placement precisely: native bounds (size + half-extent), pivot_offset (bounds center relative to the mesh pivot), bounding sphere radius, the REAL collision shape (convex hulls with vertex counts, boxes, spheres, capsules) which conveys weird shapes far better than an AABB, named sockets with local transforms, and vertex/triangle/LOD/material counts.

  cfa get_mesh_info --mesh-path "/Engine/BasicShapes/Cube.Cube"
  cfa get_mesh_info --mesh-path "/Game/Meshes/SM_Rock" --include-collision=true

Spawn many actors from one computed array in a single call

Spawns a whole layout (city, pyramid, grid...) at once from a JSON array of specs, in a single undo transaction. Each entry: {mesh, location [x,y,z], rotation [p,y,r], scale [x,y,z], name, type}. Top-level 'mesh'/'type'/'name_prefix' act as defaults so a shared-mesh batch stays compact. Far faster than one spawn per actor (one bridge call, one mesh load per unique path). Pass the params via --json - (stdin) for large batches. Every entry is checked first (type, transform, mesh): one bad entry fails the whole batch, lists every bad entry, and spawns nothing. Returns spawned (and names with --return-names). Manage/revert afterwards with delete_actors_batch --name-prefix.

  # build the whole layout in one call (params piped as JSON on stdin)
  echo '{"mesh":"/Engine/BasicShapes/Cube.Cube","name_prefix":"City_","actors":[{"location":[0,0,0],"scale":[10,10,1]},{"location":[500,0,250],"scale":[3,3,5]}]}' | cfa spawn_actors_batch --json -

Bulk-delete actors by name/label prefix or an explicit list

Deletes every actor whose label/name starts with name_prefix, and/or is in the names list, in a single undo transaction. Reverts a spawn_actors_batch in one call. Every entry in names must match an actor label or object name; an unmatched name fails the call with the closest labels and deletes nothing.

  cfa delete_actors_batch --name-prefix "City_"
  echo '{"names":["Ramp_A","Ramp_B"]}' | cfa delete_actors_batch --json -

Put actors into an outliner folder (organization only)

Moves selected actors into a named outliner folder (auto-created; '/' nests). Folders are pure organization, no transform effect. Select actors via name_prefix and/or names; an entry in names that matches no actor fails the call and moves nothing.

  cfa move_actors_to_folder --folder "Structures/Pyramid" --name-prefix "Brick_"

Create an empty outliner folder

Creates an empty outliner folder (World-Partition aware). Use move_actors_to_folder or spawn_actors_batch --folder to populate it.

  cfa create_folder --folder "Structures"

Delete an outliner folder (and subfolders)

Deletes an outliner folder by enumerating the world's real folders and removing the exact match (World-Partition safe). Recursive by default (also removes subfolders). Actors inside move up to the parent (not deleted). Returns the count actually removed.

  cfa delete_folder --folder "Structures"

List all outliner folders in the level

Enumerates every outliner folder (World-Partition aware). Use to verify folder create/delete. Optional filter matches a substring.

  cfa list_folders
  cfa list_folders --filter "Structures"

Rename/move an outliner folder

Renames an outliner folder (and moves its actors + subfolders). A missing folder (the error lists the existing ones), a new path equal to or inside the old one, or a rename the editor refuses fails the call.

  cfa rename_folder --folder "Structures" --new-folder "Buildings"

Group actors into an editor Group (AGroupActor)

Creates an editor Group from the selected actors (select one -> selects all, like Ctrl+G). Different from folders (organization) and attachment (transform). Select via name_prefix and/or names (>=2 actors); an entry in names that matches no actor fails the call.

  cfa group_actors --name-prefix "Brick_"

Dissolve the editor Group(s) containing the given actors

Ungroups the AGroupActor(s) that contain the selected actors. Select via name_prefix and/or names; an entry in names that matches no actor fails the call.

  cfa ungroup_actors --name-prefix "Brick_"

Attach actors as children of a parent (transform hierarchy)

Attaches child actors to a parent so moving/rotating the parent moves the children (keeps world transform, so they stay put visually). Undo-able, outliner-reflected, cycle-validated. Select children via name_prefix and/or names; an entry in names that matches no actor fails the call. All or nothing: if the editor refuses any child (a cycle, a Static child under a Movable parent, another level), the call fails naming each refused child and attaches none.

  cfa attach_actors --parent "Reactor" --name-prefix "Pipe_"

Detach actors from their parent (become independent)

Detaches actors from their attachment parent (keeps world transform). Select via name_prefix and/or names; an entry in names that matches no actor fails the call.

  cfa detach_actors --name-prefix "Pipe_"

Off-screen orthographic top-down (floor-plan) render to PNG

Renders an orthographic top-down floor-plan of the whole level to a PNG off-screen (does not disturb the user's viewport). Auto-fits OrthoWidth to the level footprint. Far more legible than a perspective screenshot for understanding layout.

  cfa capture_top_down
  cfa capture_top_down --file-path "C:/Shots/floorplan.png" --resolution 2048 --padding 1.2

Set a property at any nested path on a placed actor

Writes any property on the actual placed level actor (not the CDO/Blueprint defaults). Walks paths through structs, FArrayProperty, FMapProperty, FSetProperty and static C arrays: Field[N] by index, Field[-] to append to an array or a set, Field[Key] for a map row (quote a key holding a dot, a space or a bracket). A map subscript adds or edits that one row; writing the whole map as a JSON object replaces every row. See set_object_property for the full grammar. Fires PostEditChangeProperty on the top-level FProperty so the renderer/component refresh, and marks the level dirty for save.

  cfa set_actor_property --actor-label "PostProcessVolume_1" --property-path "Settings.BloomIntensity" --property-value 2.0
  cfa set_actor_property --actor-label "PostProcessVolume_1" --property-path "Settings.bOverride_BloomIntensity" --property-value true
  cfa set_actor_property --actor-label "PostProcessVolume_1" --property-path "Settings.LensFlareTints[2]" --property-value '{"R":0,"G":1,"B":0,"A":1}'
  cfa set_actor_property --actor-label "MyMeshActor" --component-name "StaticMeshComponent" --property-path "Mobility" --property-value "Movable"

Inspect property type/clamp/enum metadata on a placed actor

Returns per-property metadata (cpp_type, ue_type, category, current_value, clamp_min/max, ui_min/max, valid_values for enums, inner/element/key/value types for containers, object_class/meta_class for refs, is_struct/is_array/is_enum/is_object/is_bool flags) PLUS a _summary header (total_available, total_returned, truncated, next_cursor, own_count, inherited_count, class_chain, categories breakdown). Object refs DO NOT auto-descend by default, use component_name to switch context, or pass descend_into_objects=true. max_entries=0 returns only the _summary so you can plan first.

  cfa get_actor_property_metadata --actor-label "PostProcessVolume_1" --property-path "Settings.AutoExposureMethod"
  cfa get_actor_property_metadata --actor-label "PostProcessVolume_1" --property-path "Settings" --filter "bloom" --depth 1
  cfa get_actor_property_metadata --actor-label "MCP_TestPointLight" --component-name "LightComponent0" --category "Light" --max-entries 20
  cfa get_actor_property_metadata --actor-label "MCP_TestPointLight" --max-entries 0
  cfa get_actor_property_metadata --actor-label "MCP_TestPointLight" --include-inherited=false --component-name "LightComponent0"

List material element slots (index, slot name, current material, override state) for any target's mesh components, placed actor, Blueprint component template, or a StaticMesh asset

Reads material slots via Epic's own mesh-component API (GetMaterialSlotNames / GetNumMaterials / GetMaterial), for any UMeshComponent (StaticMesh, SkeletalMesh, InstancedStaticMesh). Targets through the universal object resolver, the SAME addressing as set_object_property: 'actor' (+optional 'component') for a placed actor, or 'blueprint_path'/'asset_path' (+optional 'component') for a Blueprint's component template / class defaults. With no 'component' it reports EVERY mesh component on the target. Each slot: index, slot_name, current material, and whether it's an override vs the mesh default; each component is tagged source=instance|blueprint_template. 'mesh_path' reads a StaticMesh asset's slots directly. (actor_label / component_name are still accepted as aliases.)

  cfa get_material_slots --actor "SM_Chair_2"
  cfa get_material_slots --blueprint-path "/Game/BP/BP_Chair.BP_Chair"
  cfa get_material_slots --blueprint-path "/Game/BP/BP_Chair.BP_Chair" --component "Mesh"
  cfa get_material_slots --mesh-path "/Game/Meshes/SM_Chair.SM_Chair"

Assign materials per element slot to any target's mesh components, placed actors, Blueprint component templates, one or many, in a single call

Overrides materials via Epic's own UMeshComponent::SetMaterial and finalizes through the universal resolver's ApplyPropertyEdit, so a live edit reregisters the component (shows immediately) and a Blueprint-template edit persists + propagates to instances, exactly like the Details panel. Universal targeting (same addressing as set_object_property): each assignment targets by 'actor' (a placed actor), 'blueprint_path'/'asset_path' (a Blueprint's component template / class defaults), or 'name_prefix' (all matching placed actors, pairs with spawn_actors_batch). 'component' is optional (default = ALL mesh components on the target). Slot is 'slot' (index, default 0), 'slot_name' (resolved via GetMaterialIndex), or 'all_slots'. 'material' is an asset path, or empty string to clear the override back to the mesh default. Pass 'assignments' (an array) to do many at once. Returns applied_count + per-result {component, source, slots, material} + errors (a bad slot lists the valid indices AND slot names).

  cfa set_materials_batch --actor "TC_Orange" --material "/Game/CFATest/Materials/M_Orange.M_Orange"
  cfa set_materials_batch --name-prefix "TC_" --slot 0 --material "/Game/CFATest/Materials/M_Concrete.M_Concrete"
  cfa set_materials_batch --blueprint-path "/Game/BP/BP_Chair.BP_Chair" --component "Mesh" --slot-name "Seat" --material "/Game/M/M_Wood.M_Wood"
  cfa set_materials_batch --json '{"assignments":[{"blueprint_path":"/Game/BP/BP_Car.BP_Car","all_slots":true,"material":"/Game/M/M_Red.M_Red"},{"actor":"Wheel","slot":1,"material":""}]}'

Spawn ANY AActor subclass, engine, plugin, or Blueprint

Resolves class_path as full UClass path ("/Script/Engine.PostProcessVolume"), Blueprint asset path ("/Game/BP_Miner"), or short name ("PostProcessVolume"). Validates child of AActor + not abstract + not deprecated. Uses UEditorActorSubsystem::SpawnActorFromClass when available so Ctrl+Z restores. Replaces the legacy whitelist of spawn_actor. location, rotation and scale must each be three numbers ([x,y,z], {"x":..,"y":..,"z":..}, "x,y,z" or "(X=..,Y=..,Z=..)"; rotation as pitch,yaw,roll); a bad field fails before anything is spawned.

  cfa spawn_actor_by_class --class-path "/Script/Engine.PostProcessVolume" --name "GlobalPP" --location "[0,0,0]"
  cfa spawn_actor_by_class --class-path "/Script/Engine.SkyAtmosphere"
  cfa spawn_actor_by_class --class-path "/Game/Blueprints/BP_Miner.BP_Miner_C" --location "[500,0,100]" --rotation "[0,90,0]"

Flexible actor search by name, label, class, or tag

Combine any number of filters (all AND'd together) to query the level. Useful to confirm an actor exists, list all of a class, or filter by tag. Returns total_scanned/total_matched even when truncated, so you know if you need to widen max_results.

  cfa find_actors --label-pattern "Light" --max-results 10
  cfa find_actors --class-filter "PointLight" --include-transform=true
  cfa find_actors --class-filter "/Script/Engine.PostProcessVolume" --exact-class=true
  cfa find_actors --tag "MCPModified"
  cfa find_actors --name-pattern "Conveyor" --class-filter "ConveyorBeltActor" --max-results 5

Get property values from a live placed actor instance

Reads the placed instance (not CDO). flat=false returns nested JSON with top-level filter; flat=true returns dotted-path dict with path-aware filter, depth limit, and optional per-property metadata, use this for searching deep into structs like FPostProcessSettings.

  cfa get_actor_properties --actor-label "PostProcessVolume_1" --filter "bloom"
  cfa get_actor_properties --actor-label "PostProcessVolume_1" --flat=true --filter "bloom" --max-depth 4
  cfa get_actor_properties --actor-label "MyActor" --include-components=true --flat=true --include-metadata=true

Close the connected Unreal Editor the safe way (no process kill)

Shuts down the editor this command is routed to through Unreal's own graceful shutdown, exactly like File > Exit, instead of killing it by PID. By default it discards unsaved changes (like clicking Don't Save). Pass --save to write every unsaved map and asset first. Either way the save and confirm popups are skipped, so it works whether or not the editor was launched unattended. The editor exits a moment after this command returns its result.

  cfa quit_editor
  cfa quit_editor --save

Start Play-In-Editor (PIE), in the active viewport, or a new window

Starts a Play-In-Editor session the same way the toolbar Play button does. If a level viewport is currently active/visible, the game plays inside that viewport; if no level viewport is showing (e.g. a Blueprint editor tab is focused), it opens a separate PIE window. Pass --new-window to always open a separate window, or --simulate for Simulate-In-Editor (SIE) instead of play. The session starts a moment after this returns (RequestPlaySession is deferred). Stop it with stop_play_in_editor.

  cfa play_in_editor
  cfa play_in_editor --new-window
  cfa play_in_editor --simulate

Stop the running Play/Simulate-In-Editor session

Ends the active PIE or SIE session via Unreal's RequestEndPlayMap (the safe, deferred path). No-op if nothing is playing. The session ends a moment after this returns.

  cfa stop_play_in_editor

List the New-Level templates the editor offers (Basic, Open World, blanks, project templates)

Reads GUnrealEd->GetTemplateMapInfos(), the exact source the editor's New Level picker uses, plus the two blank options (Empty Level, Empty Open World). Each entry returns display_name, category, template_map (the asset path to pass to create_level's --template), and a partitioned flag for the blank options.

  cfa list_level_templates

Create and open a new level (blank, partitioned, or from a template)

Creates a new map at --asset-path and opens it. With no --template it makes a blank level (add --partitioned for an Empty Open World / World Partition level). With --template (a template_map path or a display name from list_level_templates, e.g. "Basic" or "Open World") it clones that template map. Mirrors ULevelEditorSubsystem::NewLevel / NewLevelFromTemplate. Save the result with save_level (already has a path), a template/blank level is opened but not yet written to disk.

  cfa create_level --asset-path /Game/Maps/MyLevel
  cfa create_level --asset-path /Game/Maps/MyWorld --partitioned
  cfa create_level --asset-path /Game/Maps/MyLevel --template "Basic"

Open an existing level in the editor

Loads the map at --asset-path into the editor (ULevelEditorSubsystem::LoadLevel).

  cfa open_level --asset-path /Game/Maps/MyLevel

Save the current level in place

Saves the currently open level (ULevelEditorSubsystem::SaveCurrentLevel). A brand-new unsaved level needs save_level_as with a path instead.

  cfa save_level

Save the current level to a new asset path

Writes the current editor world to --asset-path (UEditorLoadingAndSavingUtils::SaveMap). Use this to persist a freshly created template/blank level.

  cfa save_level_as --asset-path /Game/Maps/MyLevel

Drop a ready-to-light environment (sun, sky, fog, floor) into the current level, with optional lighting presets

Spawns a default lighting/sky rig into the current level in one call so a freshly created empty map is instantly viewable: DirectionalLight (sun), SkyAtmosphere, SkyLight, ExponentialHeightFog, and a floor plane, all filed under an Environment outliner folder. Pass --preset (clear|noon|sunset|overcast|snowy|night) to also apply a physically-grounded grade (sun angle/intensity, fog, atmosphere, exposure, saturation) following Unreal's outdoor-lighting rules, a preset forces the sky rig + a PostProcessVolume on. Without a preset, toggle parts with --sky/--floor/--clouds/--post-process/--player-start and tune the sun with --sun-pitch/--sun-yaw and the floor with --floor-size (metres).

  cfa setup_default_scene --preset clear
  cfa setup_default_scene --preset sunset --floor-size 200
  cfa setup_default_scene --preset overcast
  cfa setup_default_scene --clouds --player-start

Read the editor's undo stack, newest first

Lists the editor's undo history the way the Undo History window does. Every CFA mutation is one entry titled 'CFA: <command>' with source=cfa, while the user's own edits show source=editor, so an agent can tell its work apart from theirs. Pass --details to also report what each transaction changed: the objects touched, their classes, and the property names that differ. Use --scope mine or --scope others to filter, and --filter to match on title.

  cfa get_undo_history
  cfa get_undo_history --scope mine --details
  cfa get_undo_history --filter spawn_actor --max-results 5

Roll back the last N transactions, as Ctrl+Z does

Undoes the top of the editor's undo stack. By default (--scope mine) it stops at the first entry CFA did not author, so an agent can back its own work out without reverting the user's edits, and reports stopped_because when it stops early. The undo stack is strictly last-in-first-out, so a CFA transaction sitting below a user edit cannot be reverted on its own; check get_undo_history first. Pass --scope any to undo whatever is on top regardless of who made it.

  cfa undo
  cfa undo --count 5
  cfa undo --count 3 --scope any

Run many commands in one round trip and one undo step

Executes an ordered list of commands against the editor in a single bridge call. By default the batch is atomic: consecutive undoable steps share one transaction, so fifty edits collapse to a single Ctrl+Z, and if any step fails the whole thing is rolled back with undo. With --continue-on-error or --atomic=false each step is its own undo step and a failed step undoes only its own partial edits; --continue-on-error runs everything and reports per step, --atomic=false stops at the first failure and keeps the steps before it. --dry-run validates command names and parameters without touching the project. A step can reference an earlier step's output with "$2.asset_path", substitution only, it is a data format, not a scripting language; write "$$100" to send the literal text "$100". A rollback also deletes the assets the batch created; deleting, renaming, moving or saving assets cannot be undone, so those steps are listed under not_rolled_back. Packages a step saved are listed under saved_to_disk: their files keep the saved version, so rolled_back is then false.

  cfa batch --json '{"steps":[{"command":"spawn_actor","params":{"name":"A","location":[0,0,100]}},{"command":"spawn_actor","params":{"name":"B","location":[200,0,100]}}]}'
  cfa batch --dry-run --json '{"steps":[{"command":"spawn_actor","params":{"name":"A"}}]}'
  cfa batch --continue-on-error --json '{"steps":[...]}'

Re-apply the last N undone transactions

Redoes transactions previously undone. By default (--scope mine) it stops at the first entry CFA did not author; pass --scope any to redo whatever is next.

  cfa redo
  cfa redo --count 3