Tool reference

Create a new Environment Query (EQS) asset.

Set up navigation in the current editor level.

Author or attach Smart Objects.

Create a properly-initialized, COMPILED State Tree asset (schema + editor data + root state + compile), so it opens ready-to-edit in the State Tree editor rather than as an empty/unusable asset.

Create a Behavior Tree asset and its Blackboard from a declarative spec, then build, compile and save both.

Attach one actor to another in the current world.

Efficiently modify a property on multiple actors at once.

Detach an actor from its current parent in the world, keeping its world transform.

Read a property value on a component of an existing actor.

List the components on an existing actor.

Modify a property on an existing actor.

Set a property on a component of an existing actor.

Set the World Outliner folder of an actor.

Assign a material (base material or material instance) to a slot on a placed actor's mesh component.

Set the transform of an existing actor (undoable).

Spawn an actor in the current world. class_ref is a full class path (/Script/Engine.StaticMeshActor) or a bare engine class name (StaticMeshActor).

Assign or unassign actors to a Data Layer.

Create a Data Layer: makes a UDataLayerAsset content asset, then a DataLayerInstance in the world referencing it.

List all Data Layer instances in the world: instance name, referenced asset, type, runtime state and editor-loaded flag.

Set a Data Layer's runtime state and/or editor flags.

Capture current editor performance metrics (DrawCalls, Tris, Memory).

Add foliage instances of an existing FoliageType at explicit transforms.

List foliage types present in the level and their instance counts (summed across all foliage actors, including per-cell World Partition actors).

Remove foliage instances of a type.

Bulk-scatter foliage instances across a box region.

Create and save a FoliageType (instanced static mesh) asset wrapping a UStaticMesh, so foliage tools have a type to instance.

Create a new empty level asset and open it as the active editor world.

List actors in the current editor world.

Open/load an existing level as the active editor world.

Find actors within a specific volume in the current editor world.

Save the current editor world (and its dirty sublevels).

Assemble a modular actor by spawning a base and adding multiple components.

Update existing components on a modular actor (swap meshes or materials).

Place a NavMeshBoundsVolume covering a play area in the CURRENT level - the prerequisite for any navmesh (AI MoveTo, patrols, click-to-move).

Navigation health for the CURRENT level, read-only: nav system present, NavMeshBoundsVolume count (+labels/locations), nav-data actors (RecastNavMesh), and whether navigation is built.

Rebuild navigation data for the CURRENT level - the programmatic 'Build Paths'.

Check if a navigable path exists between two points using the current NavMesh.

Deform/tile a static mesh along an existing spline actor's USplineComponent by creating one USplineMeshComponent per segment (start/end positions + tangents from the spline).

Spawn an actor with a USplineComponent for spline-based geometry (roads, fences, cables, paths, rails, wires).

Draw persistent debug lines and boxes in the editor viewport (undoable/reversible means they expire).

Report whether the current world is World-Partitioned, whether streaming is enabled, the runtime hash class, and per-grid settings (name, cell_size, loading_range).

Edit a World Partition runtime spatial-hash grid's config.

Create or update a NAMED specialized agent - a reusable instruction profile (markdown) that extends the base agent when activated with ex_agent_use.

List the user's persisted agent training: standing instructions at both scopes (project + global), all named agents, and which agent is active.

Persist ONE standing instruction from the user so it applies to every future session (injected into the agent's system prompt).

Activate a named agent defined with ex_agent_define (its instructions extend the base agent from the next message), or deactivate with name 'none'.

Type a prompt into the open HawkeSmith chat panel and click Send, as if a user typed it.

Create an Animation Blueprint bound to a skeleton, with a single anim player node wired to the Output Pose, then compile and save it.

Create an Animation Blueprint bound to a skeleton with a state machine (e.g. locomotion Idle/Walk/Run) driving the Output Pose, then compile and save it.

Create or update a named SOCKET on a skeleton (the editor default) so meshes/items can be attached to it — e.g. a 'hand_r_weapon' socket for holding a gun.

Inside a Blueprint's component hierarchy, attach a component to a (skeletal mesh) parent component at a named SOCKET — e.g. parent a 'WeaponMesh' under the character's mesh 'hand_r' socket so it's ...

Create a new asset from a curated type.

Delete an asset and its package from disk.

Duplicate an asset to a new location.

Read metadata for a single asset by object path (e.g. /Game/Maps/Main.Main).

Rename or move an asset.

Save an asset's package to disk.

Search the Asset Registry.

Duplicate a level (.umap) to a new asset path as a fully INDEPENDENT copy, without opening the original (a safe Save-As).

Setup Dialogue Voice and Dialogue Wave assets.

Create a new MetaSound Source asset in the project.

Spawn a looping AMBIENT sound actor (AAmbientSound) in the current level, playing an imported USoundBase (e.g. a HawkeModel-generated .wav imported with ex_audio_import).

Add a comment box to a Blueprint graph to document/group nodes.

Add a component to a Blueprint's construction script.

Add an Event Dispatcher (a Blueprint multicast delegate like OnDied / OnScoreChanged) to a Blueprint.

Add a new (empty) function graph to a Blueprint.

Add an implemented interface to a Blueprint.

Add a node to a Blueprint graph.

Add a typed user-defined pin to an editable node (custom event, function entry, function result, or tunnel).

Add a member variable to a Blueprint.

Tidy a Blueprint graph: deterministically repositions all non-comment nodes into clean left-to-right columns by execution/data depth (longest-path layering).

Compile a Blueprint asset.

Connect two pins in a Blueprint graph.

Create a new Blueprint asset.

Break pin connections in a Blueprint graph.

GREP for Blueprint graphs: search a Blueprint's graphs for nodes matching a text filter and return ONLY those nodes (with GUIDs, pins, and what each pin connects to).

Read a Blueprint's class hierarchy: parent class, generated class, and the interfaces it implements.

List functions and variables on a Blueprint asset.

List the components on a Blueprint's Simple Construction Script (name, component class, and parent).

List a Blueprint's function graphs (with their user-defined parameters) and its event-graph events (custom events and overridden events).

List the nodes (with GUIDs and pin names/directions) in a Blueprint graph.

List the variables declared on a Blueprint, with friendly type, category, and default value.

Reposition a node in a Blueprint graph (for tidying / laying out a graph).

Remove a component from a Blueprint's construction script.

Remove a function graph from a Blueprint.

Remove an implemented interface from a Blueprint, dropping its interface graphs and recompiling.

Remove a node from a Blueprint graph (its connections are broken automatically).

Remove a member variable from a Blueprint.

Set a property's default value on a COMPONENT TEMPLATE inside a Blueprint's Simple Construction Script.

Set a Blueprint Custom Event's RPC/replication flags - the 'Replicates: Run on Server / Multicast / Run on Owning Client' + 'Reliable' checkboxes in the event's Details panel.

Reparent a Blueprint to a new parent class, then refresh nodes and recompile.

Set the literal default value of an unconnected input pin.

Set the default value of ANY property on a Blueprint's compiled CDO — works for BP-defined variables AND inherited properties from the parent class (e.g. 'bUseSeamlessTravel' on a GameMode subclass...

Read a property value (or list all properties) on an existing actor.

Live-Coding compile the staged C++ edits and hot-load them, returning structured diagnostics {status, success, errors, warnings, log}.

Replace the BODY of an existing member function in an existing .cpp, then (by default) Live-Coding hot-load it and AUTO-REVERT if it fails to compile.

Add a Server/Client/NetMulticast UFUNCTION RPC to a UCLASS, with the required _Implementation split.

Convert an EXISTING C++ field into a replicated UPROPERTY.

Add a new replicated UPROPERTY to a UCLASS, generating the OnRep handler + GetLifetimeReplicatedProps boilerplate + Net/UnrealNetwork.h include.

Wire an OnlineSubsystem (Null=LAN, Steam, or EOS) into the current project: enable the matching plugin in the .uproject, set DefaultPlatformService and the right NetDriver in Config/DefaultEngine.i...

Configure server travel for networked games.

Create a perception-driven melee enemy and place it in the current level: a Blueprint subclass of AHSEnemyCharacter (line-of-sight chases the player when in sight range, attacks in reach by drainin...

Wire combat AnimMontages onto a character Blueprint (AHSPlayableCharacter or AHSEnemyCharacter).

Build a whole room (floor + ceiling + 4 walls, with optional door/window openings) from boxes in ONE call, replacing ~15-40 spawn/transform calls.

Create a drop-in playable 3D character in ONE call: a Blueprint subclass of the runtime AHSPlayableCharacter (spring-arm follow camera + tuned CharacterMovement + Move/Look/Jump Enhanced Input hand...

Make a character damageable: add a 'Health'-tagged UHSGameplayMeterComponent to a character Blueprint and set its max.

Tune the combat JUICE on a playable character Blueprint (subclass of AHSPlayableCharacter): the hit-stop + camera shake + impact sound fired when its melee connects.

Create a projectile Blueprint (subclass of AHSProjectile): flies straight, drains the 'Health' meter of whatever it hits (excluding its shooter), spawns an impact Niagara burst + sound, then destroys.

Spawn a sized box StaticMeshActor (graybox primitive) in one call.

Spawn a ready-to-use articulated interactable prop in ONE call (chest|door|drawer|lever|sliding_panels), collapsing create-config -> set AssetType/Parts/Interaction -> spawn-actor -> wire-Config.

Build a SCROLLING PARALLAX BACKDROP (moving scenery past a window / side-scroller stage) in ONE call.

Spawn a SEATED player pawn (AHSSeatedPawn) at a fixed transform.

Arm a playable character (subclass of AHSPlayableCharacter): set its ProjectileClass so the Fire input (Right Mouse, created by ex_character_create) launches that projectile.

Bind an actor from the open editor level into a Level Sequence as a possessable, then save the sequence.

Add a camera-cut to a Level Sequence so it views through a camera actor, then save it.

Add a 3D transform track that animates an actor in a Level Sequence, then save it.

Create a new Level Sequence (ULevelSequence) cutscene asset and save it.

Install an owned store component into this project: downloads its install recipe and wires it in (one approval), runs any capability integrations against already-installed components, and executes ...

Read the project's install registry (Config/ExaroStudio/installed-components.json): which store components are installed, their versions, the params they were installed with, and the capabilities th...

List the components (and the base plugin) this licensed buyer owns for the current engine version, via the CodeHawke store.

Set a single property on an existing asset (any UObject asset, e.g. a Data Asset) by content path, via UE ImportText.

Create a new Data Asset instance (an asset of a UDataAsset subclass) and save it.

Create a new Data Table (UDataTable) asset bound to a row struct, and save it.

List a Data Table's row names and dump the whole table as JSON.

Upsert a row in an existing Data Table from a field->value map, then save the table.

Create a new User Defined Enum (UUserDefinedEnum) asset with the given display-name values, and save it.

Create a new String Table (UStringTable) asset and save it — the localization primitive that holds key -> source-string entries which UI/dialogue/item text reference via FText::FromStringTable, so ...

Upsert one or more key -> source-string entries into an existing String Table, then save it.

Create a new User Defined Struct (UUserDefinedStruct) asset with typed fields, and save it.

Start a packaged build of the project: spawns the engine's RunUAT BuildCookRun (cook + stage + pak + archive) DETACHED, redirects its output to a log under Saved/HawkeSmith/Package/, and returns im...

Poll the in-flight (or most recent) package build started by ex_package_build: returns {launched, running, return_code, success, pid, log_path, output_dir, elapsed_seconds, log_tail}. action=cancel...

Fast read-only pre-flight ship checks — run BEFORE ex_package_build so a missing default map / GameMode / redirector storm doesn't surface minutes into a cook.

Select an actor in the editor (focuses it in viewport/details).

Recompile changed C++ via Live Coding and hot-load it into the running editor, returning a structured result (status + errors).

Report whether a Live Coding compile is in progress, and a best-effort verdict for the most recent compile (parsed from the editor log).

Trigger Live Coding to recompile and hot-load changed C++.

Clears the tool registry and re-runs built-in tool registration.

List references to/from a package.

Capture the active editor window (UMG designer, Blueprint editor, Material editor, level editor, etc.) to a PNG so the AI can see what the user is working on.

Run an arbitrary editor console command and return its output.

Return the last N captured editor log lines.

Capture the active editor viewport to a PNG so the AI can see the current editor state.

Add a key->action mapping to an existing Enhanced Input Mapping Context, then save it.

Create a new Enhanced Input Action (UInputAction) asset and save it.

Create a new (empty) Enhanced Input Mapping Context (UInputMappingContext) asset and save it.

Scaffold a WORKING key-rebinding controls widget — the controls half of a settings menu.

Answer 'which GameMode is ACTUALLY running and is its class web sane?' in one call.

Assign the class slots on a GameMode Blueprint's defaults (CDO): the pawn, player controller, HUD, game state and player state spawned for this mode.

Set the PROJECT-WIDE default GameMode and/or default/startup maps, writing DefaultEngine.ini.

Set (or clear) the GameMode OVERRIDE on the current level's World Settings.

Upsert one dialogue node (row) into an existing FHSDialogueNode Data Table, then save it.

Create a new branching-dialogue Data Table (UDataTable with RowStruct = FHSDialogueNode) and save it.

Build a dialogue-box Widget Blueprint parented to UHSDialogueWidget, CodeHawke-Amber styled.

Scaffold a minimal centered-bottom 'Press F' prompt Widget Blueprint (parent UUserWidget, CodeHawke-Amber pill): a styled TextBlock named 'PromptText' inside a rounded Border named 'PromptPanel' (b...

Add a UHSInteractorComponent to a character/pawn Blueprint so the player can press a key to toggle the AHSInteractableProp they are looking at (a view line trace up to interact_distance, else the n...

Add a HawkeSmith inventory (UHSInventoryComponent) to an Actor Blueprint — typically the player pawn/character — and set its capacity and item DataTable on the component template.

One-approval inventory setup: create/reuse an item DataTable (seeding any provided items), then add a UHSInventoryComponent to the player Blueprint wired to that table and capacity.

Build a WORKING inventory panel Widget Blueprint parented to UHSInventoryWidget, bound to the player pawn's UHSInventoryComponent.

Define (upsert) one item in an item DataTable.

List all save slots from the on-disk catalogue (no running game required).

Build a WORKING save/load menu Widget Blueprint parented to UHSSaveMenuWidget, backed by the existing UHSSaveSubsystem.

Drive the UHSSaveSubsystem in a running PIE session: save, load, continue, or delete a save slot.

Author project Gameplay Tags (the glue for GAS, AI, items, and state).

Generate a Gameplay Ability System UAttributeSet C++ class (the keystone that the ability/effect/ASC tools act on — without it no health/damage/stamina game can be finished).

Generate a text->3D mesh on the LOCAL HawkeModel backend (no API tokens) AND auto-import it when ready.

Poll a HawkeModel generation job.

Import a mesh file (e.g. a generated .glb from HawkeModel) into the project as a UStaticMesh via Interchange.

List background asset-generation jobs started by ex_asset_generate_3d and their current state.

Submit a text->audio (WAV) generation job to the LOCAL HawkeModel backend (no API tokens).

Import an audio file (e.g. a generated .wav from HawkeModel) into the project as a USoundWave via USoundFactory.

Import an .fbx file from disk into the project as a UStaticMesh OR USkeletalMesh, handling all the painful FBX import settings as one-shot args (no import dialog).

Submit a text->image (PNG) generation job to the LOCAL HawkeModel backend (no API tokens).

Import an image file (e.g. a generated .png from HawkeModel) into the project as a UTexture2D via UTextureFactory.

Add an expression node to a base material's graph.

Batch-edit an EXISTING base material in ONE approval-gated call: add multiple nodes, wire them, connect to material properties, and tweak existing nodes — all in a single transaction, recompiled an...

Connect a material expression's output to either a material property or another expression's input, then recompile.

Create a new base material and build its whole graph in one shot, then save and recompile.

Create a standard PBR base material in one call: makes the asset, adds and wires base color, metallic and roughness (and optional emissive) nodes, recompiles, and saves to disk.

Inspect a material or material instance.

Set a scalar or vector parameter on a UMaterialInstanceConstant asset.

List the expression nodes in a base material (UMaterial, not an instance).

Modify a value on an EXISTING expression node in a base material, then recompile and save.

Verify that a base material is actually usable, not just that the editing calls succeeded.

Run a recipe from the data-driven store by id in one approval-gated call.

Search the data-driven recipe store (curated, parameterised graph builds).

Statically validate a recipe from the data-driven store by id WITHOUT running it (creates no asset).

Read the current replication flags on an actor instance or Blueprint CDO.

Toggle network-replication flags on an actor instance OR a Blueprint class's CDO defaults, and optionally on a named component.

Set network latency emulation parameters (lag, jitter, loss) using console commands.

Audit replication settings of all actors in the current level.

Add a PCG component to an actor and assign a graph.

Add a node to a PCG graph. graph_ref is the graph asset path; node_type is a UPCGSettings subclass name (e.g.

Add an exposed user parameter to a PCG graph (the graph's Parameters panel). param_type is one of: double, float, int, int64, bool, string, name, vector, rotator, transform, soft_object.

Wire an output pin of one node to an input pin of another in a PCG graph. from_node/to_node are node ids from ex_pcg_add_node (or the literal 'input'/'output' for the graph endpoints). from_pin/to_...

Create a new PCG Graph asset. asset_path is the full package path (e.g., /Game/Procedural/MyPCG).

Run/regenerate the PCG graph on an actor's component (materializes the procedural content).

List available PCG node types (UPCGSettings subclasses) with class name and display title, so you can pick a valid node_type for ex_pcg_add_node.

Set the value of an exposed PCG graph parameter.

Create a UPaperFlipbook animation from an ordered list of UPaperSprites.

Generate a fully-playable 2D side-scroller character Blueprint from flipbooks.

Place a gameplay actor in the CURRENT level to make an auto-built level an actual game: a 'pickup' (spinning collectible worth point_value), a 'hazard' (kills+respawns the player at the first Playe...

Create a UPaperSprite that wraps an ENTIRE UTexture2D (no sub-region).

Grid-slice a UTexture2D into many UPaperSprites.

Create a standalone UPaperTileMap asset (the level grid) from a UPaperTileSet, optionally placing an APaperTileMapActor in the current level.

Paint tiles into a UPaperTileMap layer — this is how the level is drawn.

Create a UPaperTileSet from a UTexture2D — the palette of tiles used to paint a tilemap level.

Audit assets via the Asset Registry.

Fixup redirectors in a folder.

Search Blueprints for specific node patterns.

Add a custom PROJECT collision channel (trace or object), writing the +DefaultChannelResponses entry to DefaultEngine.ini's [/Script/Engine.CollisionProfile] section.

Define a named PROJECT collision profile/preset (e.g. 'Projectile', 'Trigger'), writing the +Profiles entry to DefaultEngine.ini's [/Script/Engine.CollisionProfile] section.

Spawn a gameplay TRIGGER VOLUME (overlap -> reaction) in ONE call: a bare actor whose root is a box or sphere collision component set to QueryOnly + the engine 'Trigger' overlap profile, so it fire...

Walk the live PIE GameViewport's UMG widget overlay and report each widget added to viewport, plus its named child widgets.

Change the editor's Play-In-Editor settings (the Play dropdown's Advanced Settings): run_under_one_process (bool - false gives every client its own process, which un-shares render targets; the fix ...

Begin Play In Editor in the current editor world.

Returns server info and the current editor world name.

Test tool that builds a preview and, on approval, echoes its arguments back.

Read project configuration (the surface behind every settings page).

Write a key in a project Default*.ini (Engine|Game|Input|Scalability|DeviceProfiles) - the generic settings surface.

Triage the most recent editor crash: reads Saved/Crashes, extracts the assert/error message and callstack, attributes it honestly (HawkeSmith-implicated vs engine/game code), and pulls the log line...

Read engine console variables - the surface behind ~11,000 rendering/performance/scalability/debug controls (r.*, t.*, sg.*, a.*, p.* ...).

Set an engine console variable (framerate caps like t.MaxFPS, scalability sg.*, rendering r.*, debug toggles).

Windowed log reading for debugging: action 'mark' returns an offset (call BEFORE reproducing an issue), then action 'collect' with that offset returns ONLY the log lines written since - optionally ...

Collect a finished (or in-progress) observation started with ex_observe_start: the full time-series (t, location, rotation, velocity) plus summary stats (min/max Z, max speed, total XY distance, bi...

Start recording an actor's location/rotation/velocity over time (time-series sampling) - the debugger for physics, movement, and 'it happens over a few seconds' problems.

Instantaneous performance numbers as DATA (not a screenshot of stat text): average FPS, frame ms, RHI draw calls, primitives drawn, memory (physical/virtual used, texture pool).

Press a key/mouse button on a running PIE player - the agent's hands for self-verifying gameplay ('dig on client 1, watch the hole appear on the server').

Inspect EVERY running PIE world - the multiplayer debugging eyes.

List the ENABLED plugins in this project: name, version, description, engine-vs-project source, path.

Hardware + engine environment in one read-only call: GPU adapter/driver, RHI (D3D12/Vulkan...), CPU, physical memory, engine version, project name, platform.

Determine whether actors were PLACED in the level (saved to the .umap) or DYNAMICALLY SPAWNED at runtime (and by what).

Find every spawn site for an actor class: Blueprint SpawnActor/SpawnActorFromClass nodes, ChildActorComponents, GameMode default-class slots, and (best-effort) C++ source.

Inspect a UClass via reflection.

Inspect a UEnum via reflection.

Discover loaded UClasses via reflection.

Inspect a UScriptStruct via reflection.

List EVERY registered tool by name with a one-line summary - the full registry, not the curated subset shown to the agent.

Create a Material Instance (UMaterialInstanceConstant) from a parent material, with scalar/vector parameter overrides, in one call.

Configure an EXISTING light actor (Directional / Point / Spot / Rect / Sky).

Set world-level static-lighting (Lightmass) quality on the current level's WorldSettings — distinct from per-volume post-process.

Enable or disable Nanite on a Static Mesh asset.

Set color-grading / bloom / exposure and per-volume Lumen GI/Reflection method on a Post Process Volume.

One-call cinematic lighting: finds-or-spawns the full sky rig (a movable atmosphere-sun DirectionalLight + SkyAtmosphere + real-time-capture SkyLight + ExponentialHeightFog) and an unbound PostProc...

Build a gameplay HUD Widget Blueprint parented to UHSHudWidget, with a configurable set of corner-anchored, CodeHawke-Amber-styled elements on a CanvasPanel.

Build a front-end main menu in one call: a settings (sound/video) widget, an optional key-rebinding controls widget, and a MAIN menu wired to all of them — Play (loads a game level via OpenLevel), ...

Append a styled, WIRED entry to an EXISTING generated menu WBP (one with a 'MenuBox' vertical box — every ex_menu_scaffold menu has it).

Scaffold a FULLY-WIRED menu Widget Blueprint whose buttons work the moment the menu is shown — the menus every shipped game needs.

Scaffold a WORKING in-game options/settings menu backed by stock UGameUserSettings.

Simulate adding a CommonUI action bind by adding a CommonActionWidget to the widget tree.

Create a new CommonUI Activatable Widget Blueprint.

Build a complete, navigable pause UI in one call: a settings (sound/video) widget, an optional key-rebinding controls widget, and a pause menu wired to BOTH — Resume, Settings (opens the options wi...

Add a widget to a Widget Blueprint's tree.

Bind a UMG widget's event to a new event node in the Widget Blueprint's event graph (makes buttons functional).

Create a new UMG Widget Blueprint.

List the widget tree of a Widget Blueprint.

Set the CanvasPanelSlot geometry on a widget whose parent is a CanvasPanel.

Set a simple property on a widget inside a Widget Blueprint.

Add an emitter (from a NiagaraEmitter asset) to an existing Niagara system, recompile, and save.

Create a new Niagara System (UNiagaraSystem) asset and save it.

List emitter handles on a Niagara system.

Set a User-namespace parameter on a placed Niagara actor's component (e.g. color, spawn rate, scale).

Place a Niagara system in the current editor level as a NiagaraActor.

Inspect a Niagara system: emitters (name/enabled/source), user (exposed) parameters with their types, fixed bounds, and effect type.

Create a flat landscape in the current editor world.

Set the height of an inclusive quad rect on a landscape.

Spawn a correctly-wired water body in the current editor world: assigns default materials/waves/spline, ensures an overlapping AWaterZone exists (spawns one if needed), and fills the zone with the ...