¿Cómo instalo Pinwright Ue?

Copia en esta página la configuración stdio para Cursor, Claude Desktop, Claude Code o VS Code. Usa la instalación del publicador, no un proxy de PlugMCP.

¿Pinwright Ue necesita una clave de API?

Este registro no indica ninguna variable de entorno obligatoria.

¿Qué transporte usa Pinwright Ue?

Pinwright Ue se ejecuta localmente por stdio.

¿Cuándo se comprobó Pinwright Ue por última vez?

Última comprobación: 2026-11-13. Unreal Editor MCP server for AI coding agents

Servidor MCP Pinwright Ue | PlugMCP

Install PinWright into this Unreal project and connect yourself to it by following https://github.com/PinWright/pinwright-ue/blob/master/AGENT_INSTALL.md

	Yes	Partial	No
PinWright	224	87	30
ue-mcp	177	115	49
Monolith	110	151	79
ChiR24 Unreal_mcp	100	132	109
Epic UE 5.8 MCP	73	124	142
VibeUE	59	188	94

Get the plugin. Download the prebuilt zip for your engine version from Releases (Windows), install from Fab through the Epic Launcher, or clone this repository and build it (Windows and Linux). All three are the same code under MIT:
```
git clone https://github.com/PinWright/pinwright-ue.git <Project>/Plugins/PinWright
```
If you cloned it elsewhere, move the PinWright folder into your project's Plugins directory or the engine's.
Build and open. Regenerate project files if your project is a C++ source checkout, build the editor target if Unreal asks for a rebuild, then open the editor and confirm the plugin under Editor Preferences -> Plugins -> PinWright.
Click Install for your agent. The PinWright Setup screen opens on startup (Tools -> PinWright Setup reopens it). One click writes that agent's project-local MCP config with the endpoint and token already filled in, so there is no file to edit and no port to look up.
Ask for something small. For example: "Dump /Game/UI to text, then tell me which widget bindings point at variables that no longer exist."

Area	What it does	Maturity
Project inspection and dumps	Inspect assets, query dependencies, import, rename and organize; dump any asset or folder to readable text for review and accurate agent context	Core
Graph text IRs	Round-trip for Blueprint (BPIR), material (MGIR), animation Blueprint (AGIR), Control Rig (CRIR); decompile-to-text for behavior tree, sound cue, MetaSound, Niagara, PCG	Core
Blueprints and data assets	Create and edit classes, variables, functions, events and graphs; compile and decompile; author Data Tables and other data assets	Core
Widgets (UMG)	Author the widget tree, styles, bindings and animations; export and import as XML	Core
Actors, levels and system operations	Spawn actors, edit transforms, manage levels, inspect world state, read logs, run editor commands and build or test helpers	Core
Playtesting and bug fixing	Start Play-In-Editor, send input, read live game state and logs; an agent can reproduce a bug, fix it, rebuild, and play again to verify the fix	Core
Session recorder	Record a Play-In-Editor session and query it to debug what happened (needs small documented C++ hooks in your game for gameplay values)	Core
Model generation	`.pwmodel` text recipes of geometry operations compile into Static Mesh assets, with materials, collision and UVs; live modeling helpers on placed meshes (`geometry`, `model`)	Core
Skeleton and animation generation	`.pwskel` defines skeletons, skin weights, sockets and physics assets; `.pwanim` compiles animation clips; helpers for montages, blend spaces, IK and retargeting (`skeleton`, `animation`, `anim`)	Core
Level generation	Landscape terrain (grid spawn, sculpting, noise seeding), foliage, sky, fog and time of day, plus spatial reasoning: raycasts, surface placement and annotated captures so the agent places things by measurement (`landscape`, `environment`, `foliage`, `spatial`)	Core
Materials and Niagara	Material graph authoring through MGIR; Niagara system and emitter editing	Core

Operation	What it does
`asset.bulk_delete`	Delete many assets in a single call.
`asset.bulk_rename`	Apply prefix/suffix/search-replace transformations to many asset names in one call.
`asset.create_folder`	Create a folder in the content browser
`asset.delete`	Delete one or more assets or whole content folders.
`asset.dependencies`	Get assets that reference this asset (inbound referencers).
`asset.dump`	Dump an asset's full inspectable state to disk as separate text files.
`asset.dump_folder`	Start an async dump of every asset under a content folder.
`asset.duplicate`	Duplicate an asset or folder
`asset.exists`	PIE-safe existence probe via the asset registry, loaded objects, and mounted package files.
`asset.find_by_tag`	Search the asset registry for assets whose UMetaData contains a given tag, optionally filtered by tag value.
`asset.find_objects_by_tag`	Find actors and components in the world by tag
`asset.fixup_redirectors`	Walk redirectors left behind by asset.rename / asset.move.
`asset.generate_lods`	Auto-generate UE's standard LOD chain for one or more StaticMesh assets using the default reduction settings.
`asset.generate_thumbnail`	Render an asset's thumbnail offscreen and optionally write it to disk.
`asset.get`	Read summary metadata (name, class, package, asset registry tags) for one asset by path.
`asset.get_asset_graph`	Get asset dependency graph via BFS traversal
`asset.get_dependencies`	Return assets that the given asset directly hard-references (Hard package dependencies).
`asset.get_dependencies_classified`	Get classified asset dependencies with mode and role filtering
`asset.get_material_stats`	Get a material's compiled shader statistics.
`asset.get_metadata`	Read all UMetaData key/value entries plus class-derived tags for one asset.
`asset.import`	Import a file from the local filesystem into the content browser using the matching UFactory.
`asset.is_dirty`	Read whether ONE loaded package currently needs saving.
`asset.list`	Browse a FOLDER: assets plus subfolders under one package path, with filtering and pagination.
`asset.list_material_instances`	List material instances that use a given parent material
`asset.map_references`	Return soft-UWorld UPROPERTY references for a single loaded asset, matching map_references.json from asset.dump.
`asset.mark_dirty`	Mark ONE loaded package dirty without writing anything to disk.
`asset.move`	Move an asset to a different folder and leave a redirector at the old path.
`asset.nanite_rebuild_mesh`	Toggle Nanite and/or rebuild its data for a StaticMesh.
`asset.references`	Get both directions for one asset.
`asset.reload`	Force-evict a loaded asset package and re-read it from disk within the current editor session.
`asset.rename`	Rename an asset and create a redirector at the old path so existing references keep resolving.
`asset.reset_instance_parameters`	Reset all parameter overrides on a material instance
`asset.save`	Persist ONE loaded asset to disk.
`asset.search`	FIND AN ASSET BY NAME - the answer to "which asset is called something like X?".
`asset.search_assets`	List assets by CLASS and/or package path - the no-name-in-hand path ("every SoundWave", "everything under /Game/Maps").
`asset.set_metadata`	Write key/value metadata onto an asset's UMetaData store.
`asset.set_tags`	Write boolean metadata tags on an asset (each tag is stored as key=true in UMetaData).
`asset.source_control_checkout`	Check out assets from source control
`asset.source_control_submit`	Submit assets to source control
`asset.validate`	Validate if an asset exists and can be loaded

Operation	What it does
`blueprint.add_construction_script`	Ensure a construction script graph exists on a blueprint
`blueprint.add_dispatcher`	Add an Event Dispatcher member variable and delegate signature graph to a Blueprint.
`blueprint.add_enum_entries`	Append enumerators to an existing user-defined enum.
`blueprint.add_event`	Add an event entry node to a Blueprint's EventGraph.
`blueprint.add_function`	Create a new UFunction graph on a Blueprint with caller-specified input/output pins.
`blueprint.add_interface`	Make a Blueprint implement a Blueprint Interface.
`blueprint.add_macro`	Create a new Blueprint macro graph with caller-specified tunnel input/output pins.
`blueprint.add_struct_field`	Add a field to a user-defined Blueprint struct.
`blueprint.add_variable`	Add a member variable to a Blueprint class.
`blueprint.build_api_index`	Scan all UClasses via reflection and write a Blueprint-callable API index to Saved/AI/ApiIndex.json
`blueprint.compile`	Run UE's Blueprint compiler on the named asset and return any compile errors/warnings.
`blueprint.compile_batch`	Compile many Blueprints in ONE call (an explicit list or a content folder) and report one row per Blueprint.
`blueprint.compile_bpir`	Compile BPIR (Blueprint IR) code into Blueprint graph nodes
`blueprint.create`	Create a new UBlueprint asset deriving from a parent UClass.
`blueprint.create_bpir_expression`	Create a BPIR expression node in a blueprint graph
`blueprint.create_enum`	Create a UUserDefinedEnum asset usable in Blueprint variables and pin defaults.
`blueprint.create_struct`	Create a UUserDefinedStruct asset usable in Blueprint variables and as a TMap value type.
`blueprint.decompile`	Decompile Blueprint graphs into BPIR (Blueprint IR) text
`blueprint.decompile_function`	Decompile a specific Blueprint function to BPIR text
`blueprint.decompile_macro`	Decompile a specific Blueprint macro to BPIR text
`blueprint.delete_unused_variables`	Find and optionally delete unused member variables in a Blueprint
`blueprint.ensure_exists`	Idempotent BP existence guard: probes the asset and creates it (via blueprint.create) when missing.
`blueprint.exists`	Check whether a blueprint asset exists
`blueprint.get`	Return summary metadata for a Blueprint.
`blueprint.get_node_connections`	Get pin connections for a node (upstream and downstream)
`blueprint.graph.break_pin_links`	Break all links on a pin
`blueprint.graph.connect_pins`	Wire an output pin to an input pin between two existing graph nodes.
`blueprint.graph.connect_pins_batch`	Wire many output->input pin pairs in one Blueprint graph in one call and one undo transaction.
`blueprint.graph.create_node`	Spawn a single graph node in an existing UEdGraph and return its node id.
`blueprint.graph.create_reroute_node`	Create a reroute (knot) node
`blueprint.graph.delete_node`	Delete a node from a blueprint graph
`blueprint.graph.delete_orphaned_nodes`	Delete orphaned nodes (unconnected, side-effect-free) from a blueprint graph.
`blueprint.graph.find_node_types`	Search the Blueprint action database for spawnable node types.
`blueprint.graph.find_nodes`	Search for nodes matching a query string
`blueprint.graph.find_orphaned_nodes`	Find blueprint graph nodes unreachable from any entry point (read-only)
`blueprint.graph.get_execution_flow`	Walk execution pin connections from a starting node (BFS)
`blueprint.graph.get_graph_connections`	Get all connections in a blueprint graph
`blueprint.graph.get_graph_details`	Get details about a specific graph including its nodes
`blueprint.graph.get_node_details`	Get detailed information about a specific node
`blueprint.graph.get_node_details_batch`	Get details for multiple nodes in one call
`blueprint.graph.get_node_type_pins`	Return the expected pin list for a node type id from blueprint.graph.find_node_types (spawn-and-scan)
`blueprint.graph.get_nodes`	Get all nodes in a blueprint graph
`blueprint.graph.get_pin_details`	Get details about a node's pins
`blueprint.graph.get_pin_details_batch`	Get pin details for multiple nodes in one call
`blueprint.graph.list_graphs`	Enumerate every UEdGraph in a Blueprint.
`blueprint.graph.list_node_types`	List all available K2Node types for node creation
`blueprint.graph.reconstruct_node`	Reconstruct one K2 node in memory after a shape-changing reflected property write, refresh the graph.
`blueprint.graph.replace_node`	Substitute one node for another in place, transferring matched pin connections and defaults.
`blueprint.graph.set_node_property`	Set one supported presentation property on a Blueprint graph node.
`blueprint.graph.set_pin_default_value`	Set the default value on a node's input pin
`blueprint.graph.set_pin_default_values`	Batch set default values on multiple node pins
`blueprint.insert_bpir_at_node`	Insert BPIR code after a selected node in the graph
`blueprint.insert_bpir_before_node`	Insert BPIR code before a selected node in the graph
`blueprint.inspect`	Blueprint summary: metadata, variables, functions, events, components, graphs, references, and warnings.
`blueprint.list`	Enumerate blueprint assets with filters and paging.
`blueprint.list_struct_fields`	List fields in a user-defined Blueprint struct
`blueprint.modify_scs`	Batch modify Blueprint Simple Construction Script (SCS) components
`blueprint.preview_construction`	Run an Actor Blueprint's construction scripts (SCS + UserConstructionScript) on a throwaway transient.
`blueprint.probe_handle`	Lightweight check for blueprint existence without loading
`blueprint.record_dispatcher`	Record a Blueprint Event Dispatcher (or any dynamic multicast delegate) firing on a live object.
`blueprint.references`	Find asset/class references used by blueprint graph nodes and pins
`blueprint.remove_event`	Remove an event from a Blueprint
`blueprint.remove_function`	Remove a function or macro graph from a Blueprint
`blueprint.remove_interface`	Remove a Blueprint Interface implementation from a Blueprint.
`blueprint.remove_struct_field`	Remove a field from a user-defined Blueprint struct
`blueprint.remove_variable`	Remove a variable from a blueprint
`blueprint.rename_variable`	Rename a variable in a blueprint
`blueprint.reparent`	Change the parent UClass of a Blueprint.
`blueprint.scs.add_component`	Add a component template to a Blueprint's class-level SCS tree (every spawned instance will get this component).
`blueprint.scs.duplicate_component`	Duplicate a Blueprint SCS component template, optionally copying children, properties, attachment.
`blueprint.scs.get`	Read the Simple Construction Script (SCS) component tree of a Blueprint class.
`blueprint.scs.remove_component`	Remove a component from a Blueprint's SCS
`blueprint.scs.reparent_component`	Reparent a component in a Blueprint's SCS hierarchy
`blueprint.scs.set_property`	Set a UPROPERTY on an SCS component template (class-level default), so every newly spawned instance picks it up.
`blueprint.scs.set_spline_points`	Author the point data of a USplineComponent that lives in a Blueprint's SCS (class template).
`blueprint.scs.set_transform`	Set transform of a component in a Blueprint's SCS
`blueprint.search`	Search all indexed Blueprint assets using UE's Find-in-Blueprints system
`blueprint.search_api`	Keyword search over the API index built by blueprint.build_api_index
`blueprint.set_default`	Mutate the Blueprint's class default object (CDO) so every newly spawned instance starts with this value.
`blueprint.set_enum_entries`	Replace user-defined Blueprint enum entries with new names.
`blueprint.set_function_settings`	Set Blueprint function settings (access, pure/const/exec, call-in-editor, category)
`blueprint.set_metadata`	Set metadata on a blueprint asset
`blueprint.set_struct_field_default`	Set the default value for an existing user-defined struct field.
`blueprint.set_struct_field_metadata`	Set or clear a metadata key on an existing user-defined struct field.
`blueprint.set_variable_metadata`	Apply metadata to a Blueprint variable
`blueprint.set_variable_settings`	Set Blueprint variable settings (visibility, editable/read-only, expose-on-spawn, replication, and category)
`blueprint.undo_last_bpir`	Undo the last BPIR compilation by deleting created nodes
`blueprint.update_bpir_expression`	Update the BPIR text of an existing expression node

Operation	What it does
`data_table.add_row`	Add a new row to a DataTable.
`data_table.create`	Create a new UDataTable asset bound to a row struct, so the row-CRUD verbs have a table to author.
`data_table.list_rows`	Return the DataTable's rowStruct, rowCount, and rows map (same shape as data_table.json asset dumps).
`data_table.remove_row`	Remove a row from a DataTable.
`data_table.set_row`	Overwrite an existing row's values from JSON.
`data_table.set_row_struct`	Rebind a DataTable to a different row struct.

Operation	What it does
`chooser.add_column`	Append a first-slice chooser column.
`chooser.add_row`	Append a chooser row and initialize column cell storage.
`chooser.compile`	Compile a chooser table and return diagnostics.
`chooser.create`	Create a UChooserTable asset.
`chooser.set_cell`	Set a chooser cell value using the stored column kind.
`chooser.set_result`	Set a chooser row result.

Operation	What it does
`input.add_mapping`	Bind a hardware key to an Input Action inside an Input Mapping Context.
`input.create_input_action`	Create a new Enhanced Input UInputAction asset at the given folder.
`input.create_input_mapping_context`	Create a new Enhanced Input UInputMappingContext (IMC) asset.
`input.get_input_info`	Inspect an Input Action or Input Mapping Context asset.
`input.remove_mapping`	Unbind every key currently mapped to an Input Action inside an Input Mapping Context.

Operation	What it does
`texture.adjust_curves`	Adjust color curves
`texture.adjust_levels`	Adjust levels
`texture.blur`	Blur texture
`texture.channel_extract`	Extract channel
`texture.channel_pack`	Pack channels
`texture.combine_textures`	Full-frame blend of two same-size textures (no placement; overlay alpha ignored)
`texture.configure_virtual_texture`	Configure VT settings
`texture.create_from_pixels`	Create a texture from caller-supplied pixel data (base64 RGBA8 or Gray8 bytes, row-major from the top-left).
`texture.create_gradient_texture`	Create a procedural gradient texture
`texture.create_noise_texture`	Create a procedural FBM noise texture (Perlin value noise or Worley/Voronoi cellular)
`texture.create_normal_from_height`	Generate a normal map from height
`texture.create_pattern_texture`	Create a procedural pattern texture
`texture.create_render_target`	Create render target
`texture.create_text_texture`	Create a texture with text rasterised from a real font.
`texture.desaturate`	Desaturate texture
`texture.describe`	Describe any UTexture subclass using the texture dump JSON shape
`texture.get_pixel_stats`	Read live source-mip pixel content (per-channel mean/min/max, grayscale flag, content hash) so.
`texture.get_texture_info`	Get texture info
`texture.invert`	Invert texture
`texture.resize_texture`	Resize texture
`texture.set_compression_settings`	Set texture compression settings
`texture.set_lod_bias`	Set texture LOD bias
`texture.set_srgb`	Set a texture's sRGB flag: off for linear data (masks, noise, packed channels), on for colour.
`texture.set_streaming_priority`	Set streaming priority
`texture.set_texture_filter`	Set filter
`texture.set_texture_group`	Set texture group
`texture.set_texture_wrap`	Set wrap mode
`texture.sharpen`	Sharpen texture

Operation	What it does
`geometry.append_buffers`	Bulk-append vertices + indexed triangles (with optional per-vertex normals/UVs/colors) to a DynamicMeshActor.
`geometry.append_triangle`	Add a triangle to a dynamic mesh by specifying three vertex positions
`geometry.append_vertex`	Add a single vertex to a dynamic mesh
`geometry.array_linear`	Merge offset copies of a dynamic mesh into its own geometry (does not spawn new actors)
`geometry.array_radial`	Merge rotated copies of a dynamic mesh into its own geometry around a center (does not spawn new actors)
`geometry.audit_skeletal_animation_floating`	Evaluate a skeletal mesh in the actual frames of an animation sequence and report the component islands.
`geometry.audit_static_meshes`	Sweep a folder (or a named set) of SAVED StaticMesh assets in ONE call and report the ones that are.
`geometry.auto_uv`	Alias of geometry.unwrap_uv (same XAtlas auto-unwrap); accepts uvChannel, defaults to channel 0
`geometry.bake_ambient_occlusion`	Ray-cast a dynamic mesh against itself and write the resulting ambient-occlusion term into chosen.
`geometry.bend`	Apply bend deformer to a dynamic mesh
`geometry.bevel`	Apply bevel to safe polygroup edges of a dynamic mesh.
`geometry.bind_skin_weights`	Bind a DynamicMeshActor's mesh to a skeleton, writing BASE skin weights for every vertex in one call.
`geometry.boolean_intersection`	Perform boolean intersection of two dynamic mesh actors
`geometry.boolean_subtract`	Perform boolean subtraction of two dynamic mesh actors
`geometry.boolean_trim`	Trim a mesh using another mesh as a cutting tool.
`geometry.boolean_union`	Perform boolean union of two dynamic mesh actors
`geometry.bridge`	Bridge between boundary loops of a dynamic mesh with a single triangle strip
`geometry.check_health`	Report geometry defects of a dynamic mesh (read-only).
`geometry.convert_to_skeletal_mesh`	Bake a DynamicMeshActor into a SkeletalMesh asset and force it to disk.
`geometry.convert_to_static_mesh`	Bake a dynamic mesh into a StaticMesh asset.
`geometry.create_arch`	Create an arch (partial torus) dynamic mesh actor
`geometry.create_box`	Create a box/cube dynamic mesh actor.
`geometry.create_capsule`	Create a capsule dynamic mesh actor
`geometry.create_cone`	Create a cone dynamic mesh actor
`geometry.create_cylinder`	Create a cylinder dynamic mesh actor
`geometry.create_disc`	Create a disc dynamic mesh actor
`geometry.create_from_skeletal_mesh`	Load an existing SkeletalMesh asset into an editable DynamicMeshActor.
`geometry.create_from_static_mesh`	Load an existing StaticMesh asset (or the mesh of a placed actor) into an editable DynamicMeshActor.
`geometry.create_pipe`	Create a hollow pipe dynamic mesh actor
`geometry.create_plane`	Create a plane/rectangle dynamic mesh actor
`geometry.create_procedural_mesh`	Create an empty DynamicMeshActor for procedural mesh building
`geometry.create_ramp`	Create a ramp (wedge) dynamic mesh actor
`geometry.create_ring`	Create a ring (disc with hole) dynamic mesh actor
`geometry.create_sphere`	Create a box-topology sphere dynamic mesh actor: a rounded cube, with no poles and no seam.
`geometry.create_spiral_stairs`	Create a curved/spiral staircase dynamic mesh actor
`geometry.create_stairs`	Create a linear staircase dynamic mesh actor
`geometry.create_torus`	Create a torus dynamic mesh actor
`geometry.cylindrify`	Project vertices of a dynamic mesh toward a cylinder
`geometry.delete_triangle`	Remove a triangle from a dynamic mesh
`geometry.delete_triangles_by_bone_influence`	Delete a skinned dynamic mesh's triangles by skin weight.
`geometry.delete_vertex`	Remove a vertex from a dynamic mesh (also removes connected triangles)
`geometry.difference`	Perform boolean subtraction (alias for boolean_subtract)
`geometry.duplicate_along_spline`	Duplicate an actor along a spline path
`geometry.edge_split`	Split edges of a dynamic mesh by inserting midpoint vertices
`geometry.export_obj`	Export a DynamicMeshActor's mesh as Wavefront OBJ text (v/vt/vn/f).
`geometry.export_stl`	Export a DynamicMeshActor's mesh as STL (ASCII by default, or binary).
`geometry.extrude`	Extrude faces of a dynamic mesh
`geometry.extrude_along_spline`	Extrude a profile along a spline path
`geometry.fill_holes`	Fill all holes in a dynamic mesh
`geometry.flip_normals`	Flip all normals on a dynamic mesh
`geometry.generate_collision`	Generate collision shapes for a dynamic mesh
`geometry.generate_complex_collision`	Generate complex collision using convex decomposition
`geometry.get_mesh_info`	Get information about a dynamic mesh.
`geometry.get_vertex_position`	Get the position of a vertex in a dynamic mesh
`geometry.import_obj`	Import Wavefront OBJ (from text or filePath) into a NEW DynamicMeshActor.
`geometry.import_stl`	Import STL (ASCII from text or filePath; binary from filePath only) into a NEW DynamicMeshActor.
`geometry.inset`	Inset faces of a dynamic mesh (shrink inward)
`geometry.loft`	Loft a surface between cross-section profiles
`geometry.measure`	Measure a dynamic mesh (read-only).
`geometry.merge_vertices`	Merge nearby vertices on a dynamic mesh
`geometry.mirror`	Mirror a dynamic mesh across a specified axis.
`geometry.noise_deform`	Apply Perlin noise deformation to a dynamic mesh
`geometry.offset_faces`	Offset faces of a dynamic mesh along normals
`geometry.outset`	Outset faces of a dynamic mesh (expand outward)
`geometry.pack_uv_islands`	Repack the existing UV islands of a dynamic mesh into the unit square, leaving the seams where they are
`geometry.poke`	Poke faces of a dynamic mesh (offset + subdivide)
`geometry.project_uv`	Apply UV projection (box, planar, or cylindrical) to a dynamic mesh
`geometry.recalculate_normals`	Recalculate normals on a dynamic mesh
`geometry.recompute_tangents`	Recompute tangents on a dynamic mesh.
`geometry.relax`	Apply relax (Laplacian smoothing) to a dynamic mesh
`geometry.remesh_uniform`	Apply uniform remeshing to a dynamic mesh
`geometry.remove_degenerates`	Repair degenerate triangles on a dynamic mesh in place, keeping a closed mesh closed.
`geometry.revolve`	Create a dynamic mesh actor by revolving an open profile path around the local Z axis.
`geometry.self_union`	Apply self-union to resolve self-intersections in a mesh
`geometry.set_lod_settings`	Configure LOD reduction settings for a specific LOD level
`geometry.set_uvs`	Set UV coordinates on a dynamic mesh vertex
`geometry.set_vertex_color`	Set vertex colors on a dynamic mesh
`geometry.set_vertex_position`	Set the position of a vertex in a dynamic mesh
`geometry.shell`	Apply shell/solidify to a dynamic mesh (creates inner wall)
`geometry.simplify_collision`	Simplify mesh and regenerate collision with fewer hulls
`geometry.simplify_mesh`	Simplify a dynamic mesh to a target percentage of triangles
`geometry.smooth`	Apply iterative smoothing to a dynamic mesh
`geometry.spherify`	Project vertices of a dynamic mesh toward a sphere
`geometry.split_normals`	Split normals on a dynamic mesh based on angle threshold
`geometry.stretch`	Stretch a dynamic mesh along an axis
`geometry.subdivide`	Subdivide a dynamic mesh (PN tessellation)
`geometry.sweep`	Sweep a cross-section profile along a path or spline
`geometry.taper`	Apply taper/flare deformer to a dynamic mesh
`geometry.transform_uvs`	Transform UV coordinates (translate, scale, rotate)
`geometry.translate_mesh`	Translate (move) an entire dynamic mesh
`geometry.twist`	Apply twist deformer to a dynamic mesh
`geometry.unwrap_uv`	Auto-generate UV unwrapping for a dynamic mesh using XAtlas (geometry.auto_uv is an alias of this verb)
`geometry.weld_vertices`	Weld edges with matching vertices on a dynamic mesh

Operation	What it does
`model.compile`	Compile a .pwmodel source file into exactly one UStaticMesh or USkeletalMesh asset.
`model.describe_ops`	Index the .pwmodel vocabulary, or return complete metadata for one op or parameter set.
`model.validate`	Parse and compile a .pwmodel document without writing an asset.

Operation	What it does
`property.get`	Read a UPROPERTY value from a UObject by name and return it as JSON.
`property.list`	List properties on a UObject with current/default/override state
`property.reset`	Reset a UPROPERTY to its class default and clear explicit override metadata.
`property.set`	Set a UPROPERTY value on a UObject by name using property reflection.

Operation	What it does
`container.array.append`	Append an element to an array property
`container.array.clear`	Clear all elements from an array property
`container.array.get`	Get an element from an array by index
`container.array.insert`	Insert an element into an array at an index
`container.array.remove`	Remove an element from an array by index
`container.array.set`	Set an element in an array by index
`container.map.clear`	Clear all entries from a map property
`container.map.get`	Get a value from a map property by key
`container.map.get_keys`	Get all keys from a map property
`container.map.has_key`	Check if a map property contains a key
`container.map.remove`	Remove a key from a map property
`container.map.set`	Set a value in a map property
`container.set.add`	Add an element to a set property
`container.set.clear`	Clear all elements from a set property
`container.set.contains`	Check if a set property contains an element
`container.set.remove`	Remove an element from a set property

Operation	What it does
`object.call_function`	Invoke a UFUNCTION on any UObject (actor, component, asset, subsystem) by full path.

Operation	What it does
`static_mesh.bake_transform`	Bake a rotation/translation/uniform-scale transform into a StaticMesh asset in place.
`static_mesh.describe`	Return read-only StaticMesh metadata using the same JSON shape as static_mesh.json asset dumps.
`static_mesh.set_collision_complexity`	Set a StaticMesh asset's collision trace mode, recook its physics data, refresh loaded components, and optionally save.
`static_mesh.set_material`	Assign a material asset to a StaticMesh material slot by index and save the asset to disk.

Operation	What it does
`recorder.describe_session`	MANDATORY FIRST CALL for any recorder query.
`recorder.find_events`	Find recorded events matching a filter - the 'locate the bad moment' tool.
`recorder.get_series`	Get the change-point series of one tag of one object over a time window, reduced to a bounded set of points.
`recorder.get_state`	Get the as-of value of one recorded object's tags at a specific timestamp.
`recorder.list_segments`	Pair the session's boundary events into named, typed segment windows.
`recorder.list_sessions`	List discoverable journal-recorder sessions under Saved/PinWright/Recordings, newest first.
`recorder.query`	Run a small Python snippet over a recorded journal session.
`recorder.summarize_change`	The workhorse delta summary.

Operation	What it does
`insights.export_trace`	Extract an Unreal Insights .utrace into CSV data products.
`insights.get_trace_path`	Read-only probe that returns the current Unreal Insights trace destination and connection state without.
`insights.set_channels`	Mutate the active Unreal Insights channel set mid-trace by forwarding to the 'Trace.Enable' / 'Trace.Disable'.
`insights.snapshot`	Flush the in-memory trace ring buffer to a .utrace file via FTraceAuxiliary::WriteSnapshot without stopping.
`insights.start_session`	Start an Unreal Insights file trace (FTraceAuxiliary::Start, auto-named .utrace in the profiling directory).
`insights.stop_session`	Stop the active Unreal Insights trace via FTraceAuxiliary::Stop.

Operation	What it does
`performance.apply_baseline_settings`	Set a curated bundle of r.* render CVars (VSync, HDR, motion blur, DoF, bloom, shadow, anisotropy) tuned.
`performance.configure_lod`	Configure LOD bias and forced LOD level
`performance.configure_nanite`	Enable or disable Nanite rendering
`performance.configure_occlusion_culling`	Configure occlusion culling settings
`performance.configure_texture_streaming`	Configure texture streaming settings.
`performance.enable_gpu_timing`	Enable or disable GPU timing stats
`performance.generate_memory_report`	Run UE's 'memreport' console command and write the breakdown (or 'memreport -full' for the detailed variant).
`performance.merge_actors`	Combine 2+ static-mesh actors into a single merged StaticMeshActor (UE's mesh-merge utilities).
`performance.optimize_draw_calls`	Configure draw call optimization CVars
`performance.optimize_shaders`	Recompile shaders by mode
`performance.run_benchmark`	Measure editor frame time over a window.
`performance.set_frame_rate_limit`	Set maximum FPS limit
`performance.set_resolution_scale`	Set screen percentage / resolution scale
`performance.set_scalability`	Set the engine scalability quality level.
`performance.set_vsync`	Enable or disable VSync
`performance.show_fps`	Toggle the on-screen FPS overlay (issues 'stat fps').
`performance.show_stats`	Toggle an on-screen stat category overlay by issuing 'stat <category>'.
`performance.start_profiling`	Begin a stat-file capture by issuing 'stat startfile'.
`performance.stop_profiling`	Finalize the stat-file capture started by performance.start_profiling (issues 'stat stopfile') and return.

Operation	What it does
`editor.close_asset`	Close every editor window currently displaying the named asset.
`editor.console_command`	Execute a console command in the editor world or, via the optional 'world' selector.
`editor.create_bookmark`	Save the current viewport camera transform into one of the 10 indexed level bookmarks (Ctrl+0..9 in the editor).
`editor.create_utility_widget`	Create a new UEditorUtilityWidgetBlueprint asset (a Blutility widget).
`editor.delete_selected_graph_nodes`	Delete the currently selected nodes in the active Blueprint graph editor and mark the Blueprint dirty.
`editor.dismiss_notifications`	Close every open editor notification toast.
`editor.eject`	Eject the player controller from its possessed pawn during PIE so the camera flies free.
`editor.focus_actor`	Frame the named actor in the active viewport (equivalent to selecting it and pressing F).
`editor.frame_graph`	Frame/zoom the on-screen node graph inside a target editor window.
`editor.get_content_browser_path`	Return the folder path currently focused in the Content Browser (e.g. /Game/Foo).
`editor.get_content_browser_selection`	Return the assets currently selected in the active Content Browser as a list of {name, path, class} entries.
`editor.get_selected_graph_nodes`	Return information about every node currently selected in the most recently activated Blueprint graph editor.
`editor.jump_to_bookmark`	Move the viewport camera to a previously stored bookmark slot (0..9).
`editor.launch_standalone`	Launch one or more separate -game processes against the current project.
`editor.list_dirty_packages`	Read-only diagnostic: list every dirty (unsaved) content and world package currently in memory (count + package names).
`editor.open_asset`	Open the named asset in its default editor (Blueprint editor, material editor, etc.).
`editor.open_level`	Load and open a level (.umap) in the editor as the active world.
`editor.pause`	Pause the active Play-In-Editor session.
`editor.pie_status`	Read-only probe enumerating every live PIE world context.
`editor.play`	Start a Play-In-Editor (PIE) session for the current level and answer only after the PIE world exists.
`editor.possess`	Possess the named actor with the player controller during PIE.
`editor.quit`	Gracefully request the editor to exit.
`editor.redo`	Redo the most recently undone editor transaction(s) (Ctrl+Y equivalent).
`editor.resize_window`	Resize a top-level editor window's CLIENT area (chrome excluded).
`editor.resume`	Resume a paused Play-In-Editor session.
`editor.run_utility_blueprint`	Execute UEditorUtilitySubsystem::TryRun on a UEditorUtilityBlueprint or UEditorUtilityWidgetBlueprint.
`editor.save_all`	Save every dirty world and content package.
`editor.screenshot`	Capture a PNG screenshot into Saved/Screenshots/.
`editor.screenshot_window`	Capture a full top-level editor window (including its chrome) to a PNG under Saved/Screenshots/EditorWindow.
`editor.set_camera`	Teleport the active level-editor viewport camera to a world-space location and orientation.
`editor.set_game_view`	Toggle 'Game View' in the active viewport.
`editor.set_preferences`	Set multiple console variables in one call by passing a {cvarName: value} map.
`editor.set_view_mode`	Switch the level viewport's rendering view mode.
`editor.set_viewport_realtime`	Enable or disable continuous (realtime) rendering of the active level-editor viewport.
`editor.set_window_state`	Set a top-level editor window's maximize/minimize/restore state.
`editor.simulate_input`	Inject a synthetic keyboard or mouse event.
`editor.spawn_utility_widget_tab`	Spawn and register a dockable tab for a UEditorUtilityWidgetBlueprint, returning the tab id for later closure.
`editor.standalone_status`	Observe a -game process spawned by editor.launch_standalone in this editor session.
`editor.start_recording`	Begin a network demo recording in the active PIE game world.
`editor.status`	Read-only probe for PIE / editor state.
`editor.step_frame`	Advance the paused PIE session by exactly one frame of deltaSeconds and freeze again, world and UI together.
`editor.stop`	Stop an active or pending Play-In-Editor session and answer only after Unreal reports that no PIE session.
`editor.stop_recording`	Stop the active network demo recording via the 'DemoStop' console command.
`editor.undo`	Undo the most recent editor transaction(s) (Ctrl+Z equivalent).
`editor.undo_history`	Read-only: the editor transaction buffer.

Operation	What it does
`system.console.search`	Substring-search the live IConsoleManager registry for variables/commands matching query.
`system.console_command`	Run a console command at the process / GEngine scope.
`system.identity`	Identity of the editor PROCESS answering this call.
`system.inspect.find_by_class`	Find every actor in the resolved world (PIE-first in 'auto') whose class name (or path) matches the query.
`system.inspect.find_by_tag`	Find every actor in the resolved world (PIE-first in 'auto') that has the given Tags entry.
`system.inspect.find_objects_by_class`	Enumerate live UObject INSTANCES of a class across the whole object graph.
`system.inspect.get_game_instance`	Return the live UGameInstance for the selected world (see world) as { objectPath, className }.
`system.inspect.get_game_mode`	Return the live authoritative AGameModeBase for the selected world (see world) as { objectPath, className }.
`system.inspect.get_game_state`	Return the live AGameStateBase for the selected world (see world) as { objectPath, className }.
`system.inspect.get_local_players`	Return the live ULocalPlayers for the selected world (see world) as an array.
`system.inspect.get_player_controllers`	Return the live APlayerControllers for the selected world (see world) as an array.
`system.inspect.get_player_states`	Return the live APlayerStates for the selected world (see world) as an array of { objectPath, className, playerIndex }.
`system.inspect.get_selected_actors`	Return the actors currently selected in the level editor as {name, path, class} entries.
`system.inspect.get_viewport_info`	Return the active viewport's pixel width/height plus the level-editor camera transform.
`system.inspect.inspect_class`	Resolve a UClass by short name, U/A-prefixed name, /Script/ path.
`system.inspect.inspect_object`	Inspect a UObject (typically an actor) by path or display name and report its properties, transform.
`system.inspect.list_actor_classes`	Enumerate the distinct actor classes present in the resolved world (PIE-first in 'auto') as {class, count}.
`system.inspect.list_actor_tags`	Enumerate the distinct AActor::Tags in use across the resolved world (PIE-first in 'auto') as {tag, count}.
`system.inspect.list_objects`	Enumerate AActors in the resolved world (PIE-first in 'auto') as {name, label, path, class} entries.
`system.inspect.list_subsystems`	Enumerate live UEngine/UEditor/UGameInstance/UWorld/ULocalPlayer subsystem instances.
`system.inspect.search_classes`	Ranked keyword search over the native UClass catalog with parent / module / flag filters.
`system.job_cancel`	Stop a running long-running job.
`system.job_list`	List active and recently-completed long-running jobs
`system.job_status`	Return the status of a previously started long-running job
`system.live_coding_compile`	Trigger the editor's own in-process Live Coding compile (Ctrl+Alt+F11 equivalent), wait for it.
`system.live_coding_status`	Report in-process Live Coding availability.
`system.run_tests`	Run UE automation tests and report pass/fail counts.

Operation	What it does
`python.callbacks`	List or clear the Slate tick / Python shutdown callbacks Python scripts registered.
`python.execute`	Execute Python code or a .py file via UE's built-in Python interpreter

Operation	What it does
`source_control.connect`	Switch to / bring up a source-control provider so the namespace becomes usable
`source_control.get_provider`	Return the active source-control provider's name and connectivity flags
`source_control.log`	Return revision history for a single asset
`source_control.mark_for_add`	Mark a batch of asset paths for add
`source_control.revert`	Discard local changes for a batch of asset paths, and resynchronize the loaded packages with the reverted bytes.
`source_control.status`	Refresh and return source-control state for a batch of asset paths

Operation	What it does
`localization.compile`	Run the named project's Unreal localization Compile config as a tracked commandlet job.
`localization.gather`	Run the named project's Unreal localization Gather config as a tracked commandlet job.

Operation	What it does
`misc.create_camera`	Spawn an ACameraActor (or, with cine=true / cameraClass="cine", an ACineCameraActor) in the active level.
`misc.create_post_process_volume`	Spawn an APostProcessVolume actor in the active level.
`misc.set_camera_fov`	Set the FieldOfView property on an existing camera actor (degrees).
`misc.set_game_speed`	Set the global TimeDilation on the active world (1.0 = real-time, 0.5 = half-speed slow-mo, 2.0 = double-speed).
`misc.set_replication`	Set bReplicates and bReplicateMovement on the actor CDO of an Actor Blueprint asset.

Operation	What it does
`widget.add`	Add any widget type to a widget blueprint by class name
`widget.add_animation_keyframe`	Add a finite float key to a validated reflected float-property track without partial error-path mutation
`widget.add_animation_track`	Add a reflected float-property track for a widget after validating and staging the complete edit
`widget.bind`	Bind a widget property or bindable event to a handler function on the widget blueprint.
`widget.bind_event`	Verify/refresh an existing widget event binding.
`widget.create_widget_animation`	Create a new widget animation in a UMG widget blueprint
`widget.create_widget_blueprint`	Author a new UWidgetBlueprint asset (UMG widget).
`widget.delete_animation`	Delete a widget animation from a blueprint
`widget.describe`	Describe a widget blueprint: tree with overridden properties, slot info, and bindings per widget
`widget.duplicate`	Duplicate a widget-tree child, optionally copying its subtree, authored properties, slot data, and placement.
`widget.export_animations_json`	Export persisted UWidgetAnimation MovieScene tracks as JSON.
`widget.export_xml`	Export a widget blueprint tree as XML/HTML-like markup with all overridden properties
`widget.get_animation_info`	Get information about widget animations
`widget.get_animation_section_ranges`	Read the [start, end) range of each section in a widget animation.
`widget.get_class_properties`	Return all editable properties for one or more UMG widget classes, with struct field recursion
`widget.get_designer_visibility`	Get the editor-only Widget Blueprint hierarchy eye visibility for a widget-tree child.
`widget.import_animations_json`	Import persisted UWidgetAnimation JSON into a widget blueprint.
`widget.import_xml`	Import XML markup to build or replace a widget tree
`widget.remove_animation_binding`	Remove a specific widget binding from an animation
`widget.remove_widget`	Delete a child widget from a UWidgetBlueprint's widget tree by name.
`widget.rename_widget`	Rename a child widget within a UWidgetBlueprint's widget tree.
`widget.reparent_widget`	Move a child widget to a different parent panel within the same UWidgetBlueprint.
`widget.replace_class`	Replace a widget's class while preserving its children and (for non-root) its parent slot.
`widget.screenshot_designer`	Capture the Widget Blueprint Designer preview or containing editor window as a PNG under.
`widget.set`	Set properties and slot properties on a widget by name
`widget.set_animation_loop`	Returns NOT_SUPPORTED.
`widget.set_animation_playback_range`	Set the playback range (duration) of a widget animation
`widget.set_animation_section_range`	Set the start and/or end of every matched section in a widget animation.
`widget.set_animation_speed`	Returns NOT_SUPPORTED.
`widget.set_designer_visibility`	Set the editor-only Widget Blueprint hierarchy eye visibility for a widget-tree child without changing.
`widget.set_image_brush`	Set an FSlateBrush UPROPERTY (default 'Brush') on a widget instance from a texture/material/atlas resource.
`widget.wrap`	Wrap an existing non-root widget with a new panel widget.

Operation	What it does
`ui.activatable_pop`	Pop the active (or named) activatable widget off a stack.
`ui.activatable_push`	Instantiate an activatable widget and push it onto a UCommonActivatableWidgetContainerBase.
`ui.create_hud`	Construct a UMG widget instance from a UWidgetBlueprint and add it to the player viewport at runtime.
`ui.get_active_widget`	Return the currently-active (top) activatable widget on a stack.
`ui.list_stack_widgets`	List all activatable widgets currently on a stack, top -> bottom.
`ui.remove_widget_from_viewport`	Remove a UMG widget instance from the player viewport, undoing a prior ui.create_hud.
`ui.screenshot`	Capture a screenshot of the active viewport.
`ui.set_widget_image`	Set the Brush texture on a runtime UImage widget by name.
`ui.set_widget_text`	Set the Text property on a runtime UTextBlock widget by name (live in the viewport).
`ui.set_widget_visibility`	Set the ESlateVisibility on a runtime widget by name.

Operation	What it does
`drive.click`	Click a live UI element by handle (re-resolves the target, then settles before responding).
`drive.drag`	Drag from one live UI element to a second element or absolute point, then settle.
`drive.events_since`	Read the journal delta (events + changed variables) since a cursor; empty delta when no PIE/session is active.
`drive.expect`	Evaluate a condition against a live surface immediately (synchronous, no settle/wait).
`drive.hover`	Hover a live UI element by handle (mouse-move to its center, then settle).
`drive.input_state`	Read the live mouse-capture and focus state.
`drive.key`	Inject a key event to the focused widget; with a handle, clicks it to focus first.
`drive.list_windows`	List open top-level editor windows (title, type, geometry, index, maximized state) so an agent can target editor chrome.
`drive.observe`	Observe a live UI surface: its elements plus an optional Set-of-Mark screenshot and journal delta.
`drive.os_gesture`	Real-pointer (os_input) click or drag at a PIE game-viewport pixel or world actor, with button.
`drive.scroll`	Scroll over a live UI element by handle (mouse-wheel at its center, then settle).
`drive.type`	Type text into a live UI element by handle (clicks to focus, then types, then settles).
`drive.wait_for`	Wait for a condition to hold on a live surface, polling each frame until met or timed out.

Operation	What it does
`audio.analysis.analyze`	Measure one sound.
`audio.analysis.audit_folder`	Sweep a content folder of USoundWaves in ONE call and flag technical defects.
`audio.analysis.compare`	Measure what a candidate render differs from a reference recording BY, and in which direction.
`audio.analysis.decompose`	Take a sound apart into the three layers the synthesizer can put back together.
`audio.analysis.to_recipe`	Analysis by resynthesis.
`audio.authoring.add_cue_node`	Add a node to a SoundCue graph
`audio.authoring.add_metasound_input`	Add a graph input to a MetaSound
`audio.authoring.add_metasound_interface`	Attach a named interface to a MetaSound graph (add/remove required I/O vertices)
`audio.authoring.add_metasound_node`	Add a node to a MetaSound graph
`audio.authoring.add_metasound_output`	Add a graph output to a MetaSound
`audio.authoring.add_metasound_variable`	Add a typed graph variable to a MetaSound
`audio.authoring.add_mix_modifier`	Add a sound class modifier to a SoundMix
`audio.authoring.add_source_effect`	Add a source effect to an effect chain
`audio.authoring.compile_metasound`	Force a MetaSound to rebuild its referenced asset classes and run validation
`audio.authoring.configure_distance_attenuation`	Configure distance attenuation settings
`audio.authoring.configure_mix_eq`	Configure EQ settings on a SoundMix
`audio.authoring.configure_occlusion`	Configure occlusion settings
`audio.authoring.configure_reverb_send`	Configure reverb send settings
`audio.authoring.configure_spatialization`	Configure spatialization settings
`audio.authoring.connect_cue_nodes`	Connect two nodes in a SoundCue graph.
`audio.authoring.connect_metasound_nodes`	Connect two MetaSound nodes via an edge
`audio.authoring.create_attenuation_settings`	Create a new SoundAttenuation asset
`audio.authoring.create_dialogue_voice`	Create a new DialogueVoice asset
`audio.authoring.create_dialogue_wave`	Create a new DialogueWave asset
`audio.authoring.create_metasound`	Create an empty UMetaSoundSource asset (procedural audio graph).
`audio.authoring.create_metasound_patch`	Create an empty UMetaSoundPatch asset (a reusable MetaSound sub-graph).
`audio.authoring.create_metasound_preset`	Create a MetaSound preset asset that references an existing MetaSoundSource or MetaSoundPatch and overrides.
`audio.authoring.create_reverb_effect`	Create a new ReverbEffect asset
`audio.authoring.create_sound_class`	Create a USoundClass asset (groups sounds for shared volume/pitch/EQ control).
`audio.authoring.create_sound_concurrency`	Create a USoundConcurrency asset (a shared voice-limit group).
`audio.authoring.create_sound_cue`	Create a new USoundCue asset.
`audio.authoring.create_sound_mix`	Create a USoundMix asset (a stackable mixdown profile applying volume/pitch adjusters per SoundClass).
`audio.authoring.create_sound_submix`	Create a USoundSubmix asset (a bus in the submix routing graph).
`audio.authoring.create_sound_wave_from_pcm`	Create a USoundWave asset from raw interleaved float PCM sent inline as JSON.
`audio.authoring.create_source_effect_chain`	Create a source effect preset chain
`audio.authoring.create_source_effect_preset`	Create a USoundEffectSourcePreset asset (e.g. Filter/EQ/BitCrusher) so add_source_effect has a preset to reference.
`audio.authoring.decompile_metasound`	Decompile a MetaSound asset to MSIR text.
`audio.authoring.decompile_sound_cue`	Decompile a SoundCue graph into SCIR text.
`audio.authoring.describe_attenuation`	Describe a SoundAttenuation asset as structured JSON.
`audio.authoring.describe_dialogue_voice`	Describe a DialogueVoice asset as structured JSON.
`audio.authoring.describe_dialogue_wave`	Describe a DialogueWave asset as structured JSON.
`audio.authoring.describe_metasound`	Describe a MetaSound Source or Patch graph as structured JSON
`audio.authoring.describe_sound_class`	Describe a SoundClass as structured JSON.
`audio.authoring.describe_sound_cue`	Describe a SoundCue graph and cue-level settings (concurrency/attenuation/soundClass/volume/pitch) as structured JSON
`audio.authoring.describe_sound_mix`	Describe a SoundMix as structured JSON.
`audio.authoring.describe_sound_wave`	Describe a SoundWave as structured JSON.
`audio.authoring.disconnect_metasound_nodes`	Disconnect an edge between two MetaSound nodes by source-output / target-input names.
`audio.authoring.get_audio_info`	Get information about an audio asset
`audio.authoring.list_metasound_interfaces`	List all registered MetaSound interfaces with their input/output vertex shapes
`audio.authoring.remove_metasound_input`	Remove a graph input from a MetaSound by name
`audio.authoring.remove_metasound_interface`	Detach a named interface from a MetaSound graph
`audio.authoring.remove_metasound_node`	Remove a node from a MetaSound graph by GUID.
`audio.authoring.remove_metasound_output`	Remove a graph output from a MetaSound by name
`audio.authoring.remove_metasound_variable`	Remove a graph variable from a MetaSound
`audio.authoring.rename_metasound_input`	Rename a MetaSound graph input, preserving its type, default, and connections
`audio.authoring.rename_metasound_output`	Rename a MetaSound graph output, preserving its type and connections
`audio.authoring.search_metasound_nodes`	Search the MetaSound Frontend class registry.
`audio.authoring.set_class_parent`	Set the parent SoundClass
`audio.authoring.set_class_properties`	Set properties on a SoundClass
`audio.authoring.set_cue_attenuation`	Set attenuation settings on a SoundCue
`audio.authoring.set_cue_concurrency`	Set concurrency settings on a SoundCue
`audio.authoring.set_cue_root`	Make an existing cue node the graph's root (USoundCue::FirstNode) - the node the audio device starts playback from.
`audio.authoring.set_dialogue_context`	Add or replace a dialogue context mapping
`audio.authoring.set_metasound_default`	Set the default value of a MetaSound graph input.
`audio.authoring.set_metasound_node_input_default`	Set the literal on a node's input pin inside a MetaSound graph (not a graph input).
`audio.authoring.set_metasound_variable_default`	Set the default value of a MetaSound graph variable.
`audio.authoring.set_sound_wave_gain`	Rescale an existing USoundWave's PCM in place to a peak (dBFS) or integrated-loudness (LUFS) target.
`audio.authoring.set_sound_wave_properties`	Set per-wave properties on a USoundWave (bLooping, volume, pitch, soundGroup, compressionQuality, bMature, bSingleLine).
`audio.authoring.set_submix_parent`	Set the parent SoundSubmix for a USoundSubmix asset (mirrors set_class_parent)
`audio.authoring.validate_metasound`	Run builder-level validation on a MetaSound and return diagnostics
`audio.clear_sound_mix_class_override`	Clear a SoundMix class override
`audio.create_ambient_sound`	Spawn an AAmbientSound actor (looping/persistent audio source) at a world position with the given Sound asset.
`audio.create_audio_component`	Create a UAudioComponent in the world (attached to an actor or freestanding at a location) bound to a USoundBase.
`audio.fade_sound_in`	Fade in a sound on an actor's audio component
`audio.fade_sound_out`	Linearly ramp the volume of an actor's first AudioComponent down to a target level over fadeTime seconds.
`audio.list_active_sounds`	Read-only snapshot of every sound the audio device(s) are playing right now.
`audio.music.build_interactive`	Build one interactive MetaSound Source that plays the given stem assets as loopable, crossfadeable layers.
`audio.music.describe_schema`	Machine-readable grammar of the audio.music score.
`audio.music.export_stems`	Write each stem candidate into the project as its own USoundWave asset, named from its track name.
`audio.music.render_stems`	Render a music score to one seamless PCM stem per track.
`audio.play_sound_2d`	Non-spatialized one-shot playback of a USoundBase routed to the master submix (UI/HUD audio shape).
`audio.play_sound_at_location`	Spatialized one-shot playback of a USoundBase (cue/wave) at a world position.
`audio.play_sound_attached`	Play a sound from an AudioComponent that follows a target actor (optionally a socket).
`audio.pop_sound_mix`	Pop a SoundMix modifier from the audio stack
`audio.prime_sound`	Prime a sound asset for immediate playback
`audio.push_sound_mix`	Activate a USoundMix on the global mix stack so its class adjusters take effect (volume/pitch tweaks per SoundClass).
`audio.set_base_sound_mix`	Set the base SoundMix for the world
`audio.set_sound_mix_class_override`	Set a SoundMix class override for volume/pitch
`audio.spawn_sound_at_location`	Spawn a sound component at a world location
`audio.synth.audition`	Play a sound out loud through the editor's preview audio device (no PIE session or editor world needed), or stop it.
`audio.synth.describe_schema`	Machine-readable grammar of the audio.synth recipe.
`audio.synth.discard`	Discard one or more synth candidates by id, or every candidate with all=true.
`audio.synth.export`	Write a candidate's audio into the project as a USoundWave asset.
`audio.synth.generate`	Render a synth recipe into a session candidate and report what the render measured.
`audio.synth.get_recipe`	Return a resident candidate's CANONICAL recipe.
`audio.synth.list_candidates`	List the rendered synth candidates held in this session, newest first.
`audio.synth.patch`	Apply an RFC-6902 JSON Patch to a candidate's canonical recipe, re-parse it and render the result as a NEW candidate.
`audio.synth.render_metasound`	Render an existing MetaSound Source asset offline to PCM and measure it.
`audio.synth.variations`	Render N seeded perturbations of a candidate's recipe and return their ids beside a compact metric table.

Operation	What it does
`actor.add_component`	Add an instance-level component to a placed actor (level instance, not the BP class).
`actor.add_instances`	Append instances to an ISM/HISM component on a placed actor, in one batch, and report the indices they landed at.
`actor.add_tag`	Add an FName tag to the actor's Tags array (idempotent - adding an existing tag is a no-op and reports wasPresent=true).
`actor.apply_force`	Apply an instantaneous physics force (in unreal units, world space) to the actor's first primitive component.
`actor.attach`	Attach one actor to another using KeepWorldTransform.
`actor.create_snapshot`	Save the actor's current FTransform (location, rotation, scale) to a named in-memory snapshot keyed.
`actor.delete`	Destroy one or more actors in the current level via UEditorActorSubsystem.
`actor.delete_by_tag`	Bulk-destroy every actor in the current level whose Tags array contains the given FName.
`actor.describe`	Read a compact JSON description of one live placed actor, including identity, transform.
`actor.detach`	Detach an actor from its current parent using KeepWorldTransform.
`actor.duplicate`	Duplicate a placed actor in the same world via UEditorActorSubsystem::DuplicateActor and translate the copy.
`actor.duplicate_component`	Duplicate an instance-level component on a placed actor, optionally copying properties, attachment, transform.
`actor.export`	Serialize an actor and its components to UE's T3D (text) format and return the text in the response.
`actor.find_by_class`	Iterate the resolved world (PIE-first in 'auto') for actors of the given UClass (and subclasses).
`actor.find_by_name`	Search the current level for actors whose label, name, or path contains a case-insensitive substring.
`actor.find_by_tag`	List actors in the resolved world (PIE-first in 'auto') that match the given Tag.
`actor.get`	Read summary metadata for one placed actor: name, label, path, class, tags, location, and scale.
`actor.get_bounding_box`	Compute the actor's world-space axis-aligned bounding box including all primitive components (visible and hidden).
`actor.get_component_property`	Read a single UPROPERTY value from a named component of a placed actor and return it as JSON.
`actor.get_components`	List every component on an actor instance (or, if a Blueprint asset path is passed, the BP's CDO components).
`actor.get_instances`	Read the per-instance transforms of an ISM/HISM component on a placed actor.
`actor.get_transform`	Read the actor's current world transform.
`actor.list`	Enumerate actors in the resolved world (PIE-first in 'auto') as label/name/path/class.
`actor.nudge`	Move and/or rotate an actor by a RELATIVE delta (not an absolute transform).
`actor.remove_component`	Destroy an instance-level component on a placed actor by name (case-insensitive match).
`actor.remove_instances`	Remove instances from an ISM/HISM component on a placed actor.
`actor.remove_tag`	Remove an FName tag from the actor's Tags array.
`actor.restore_snapshot`	Restore an actor to the FTransform previously captured by actor.create_snapshot for that actor + snapshot name.
`actor.select`	Select actors in the level editor by name.
`actor.set_blueprint_variables`	Set one or more Blueprint UPROPERTY values on a placed actor instance (level instance, not the BP class default).
`actor.set_collision`	Toggle collision on the actor's root primitive component between QueryAndPhysics (enabled) and NoCollision (disabled).
`actor.set_component_properties`	Set one or more UPROPERTY values on a named component of a placed actor.
`actor.set_folder`	Assign one or more actors to a World Outliner folder path via SetFolderPath.
`actor.set_instance_transforms`	Write per-instance transforms on an ISM/HISM component, in one batch, and report what each instance WAS.
`actor.set_label`	Rename a placed actor's DISPLAY LABEL - the name the World Outliner shows - via SetActorLabel.
`actor.set_transform`	Set an actor's world transform (location, rotation, scale), optionally aiming it with lookAt.
`actor.set_visibility`	Toggle whether an actor is hidden in the level.
`actor.spawn`	Spawn an actor in the editor world.
`actor.spawn_batch`	Spawn or duplicate many actors in one call, one per entry in transforms[].
`actor.spawn_from_blueprint`	Spawn an instance of a Blueprint class into the editor world by asset path.
`actor.spawn_shape`	Spawn a /Engine/BasicShapes primitive (cube, sphere, cylinder, cone, plane) as a StaticMeshActor in one call.

Operation	What it does
`level.add_sublevel`	Attach a level package to the active world as a streaming sublevel using.
`level.audit`	Sweep every actor in the level ONCE and report the ones that are demonstrably wrong.
`level.build_all`	Run the editor's full Build All sequence: geometry, navigation, lighting, and reflection captures.
`level.build_lighting`	Build static lighting / lightmaps for the active level at the requested quality.
`level.build_navigation`	Build the navigation mesh (recast) for the active world.
`level.create`	Create a new empty (non-World-Partition) level asset.
`level.delete`	Delete a level package from the content browser.
`level.describe_offline`	List a map's actors by reading its .umap file from disk.
`level.duplicate`	Duplicate an existing level package to a new location without modifying the source.
`level.export`	Export a level to a text-format .t3d file on disk.
`level.get_actors`	List every actor that belongs to the named level (not the entire world).
`level.get_bounds`	Return the world-space axis-aligned bounding box that encloses every actor in the level (origin + extent).
`level.get_info`	Return descriptive metadata about a level.
`level.get_lighting_scenarios`	List every streaming sublevel in the active world that is flagged as a lighting scenario.
`level.list`	List the persistent level + every streaming sublevel in the active editor world.
`level.load`	Load a level package and make it the active editor world.
`level.remove_from_world`	Detach a streaming sublevel from the active world.
`level.rename`	Rename / move a level package, fixing up redirectors so existing references continue to resolve.
`level.save`	Save the active editor world's persistent level package.
`level.save_as`	Save the active editor world's persistent level under a new package path (Save As).
`level.set_locked`	Lock or unlock a level for editing.
`level.set_visibility`	Toggle the visibility flag on a streaming sublevel without unloading it.
`level.stream`	Toggle a streaming sublevel's loaded and visible state independently.
`level.structure.add_level_blueprint_node`	Add an UNBOUND stub node of the requested class to the level Blueprint's event graph.
`level.structure.assign_actor_to_data_layer`	Add the named actor to a World Partition data layer so it inherits that layer's visibility and streaming policy.
`level.structure.configure_grid_size`	Set the cell size and loading range of a World Partition grid.
`level.structure.configure_hlod_layer`	Create or update a Hierarchical LOD layer.
`level.structure.configure_level_streaming`	Update streaming-method, initial visibility, and load-on-startup flags on an existing streaming level.
`level.structure.connect_level_blueprint_nodes`	Wire two nodes in the level Blueprint's event graph by name (and optionally pin name).
`level.structure.create_data_layer`	Create a UDataLayerInstance asset and register it with the active World Partition.
`level.structure.create_level`	Create a new level package, optionally as a World-Partition map.
`level.structure.create_level_instance`	Spawn an ALevelInstance actor that embeds a level asset by reference at the given transform.
`level.structure.create_minimap_volume`	Spawn a World Partition minimap volume defining the area captured into the WP minimap texture.
`level.structure.create_packed_level_actor`	Spawn a Packed Level Actor.
`level.structure.enable_world_partition`	Report the active level's World-Partition state.
`level.structure.get_level_structure_info`	Return a structural overview of the active world.
`level.structure.open_level_blueprint`	Open the level Blueprint editor for the active level.
`level.structure.set_streaming_distance`	Configure level-streaming-volume distances and usage mode for the named streaming level.

Operation	What it does
`world_partition.cleanup_invalid_datalayers`	Remove data layer instances with missing assets
`world_partition.create_datalayer`	Create a new data layer
`world_partition.load_cells`	Load world partition cells in a region
`world_partition.set_datalayer`	Assign an actor to a data layer

Operation	What it does
`volume.add_blocking_volume`	Add a blocking volume at an existing actor's location
`volume.add_cull_distance_volume`	Add a cull distance volume at an existing actor's location
`volume.add_kill_z_volume`	Add a kill-Z volume at an existing actor's location
`volume.add_physics_volume`	Add a physics volume at an existing actor's location
`volume.add_post_process_volume`	Add a post-process volume at an existing actor's location
`volume.add_trigger_volume`	Add a trigger volume at an existing actor's location
`volume.create_audio_volume`	Create an audio volume
`volume.create_blocking_volume`	Create a blocking volume
`volume.create_camera_blocking_volume`	Create a camera blocking volume
`volume.create_cull_distance_volume`	Create a cull distance volume
`volume.create_kill_z_volume`	Create a kill-Z volume
`volume.create_lightmass_importance_volume`	Create a lightmass importance volume
`volume.create_nav_mesh_bounds_volume`	Create a nav mesh bounds volume
`volume.create_nav_modifier_volume`	Create a nav modifier volume
`volume.create_pain_causing_volume`	Create a pain-causing volume
`volume.create_physics_volume`	Create a phy