# CodeFizz Editor Agent: Full Reference

> Complete, self-contained reference for CodeFizz Editor Agent: an Unreal Engine 5 editor automation tool that lets AI assistants build inside the editor. This document mirrors the website content so an AI can answer any question about the product without visiting each page.

## What it is

CodeFizz Editor Agent is a tool for driving the Unreal Engine 5 editor with AI. A C++ plugin runs inside the editor and opens a local bridge. You send commands to that bridge with the `cfa` command line tool, or through any client that speaks the Model Context Protocol (MCP). Your AI assistant can then create and edit real content in the editor: Blueprints, Materials, Niagara systems, PCG graphs, StateTrees, data tables, level actors, Enhanced Input assets, and Unreal Insights profiling captures.

It is built for AI coding tools like Claude Code, Cursor, VS Code, and Gemini. The plugin exposes over 600 commands across 21 categories.

## Editions: free vs Pro

CodeFizz Editor Agent follows an open-core model with two editions:

- Free community edition (Unreal MCP): open source. It includes the core TCP bridge and a basic command set. It is a good way to try the workflow at no cost. It is linked from the website footer.
- Pro edition (paid): the fully maintained build. It includes the complete toolset (Niagara, PCG, StateTree, Insights, and more), regular updates, private Discord access, and support. Pro ships as compiled binaries and is closed source.

The Pro edition is recommended for production use because it is actively maintained and covers the full feature surface.

## Free trial

A free 3-day trial of the full Pro plugin is available. Start it from your account at https://codefizz.dev/account, with no credit card required. The trial unlocks the complete toolset for UE 5.6, 5.7 and 5.8 on one machine so you can try the real workflow end to end. The trial is one per account and one per machine. Activate the machine with `cfa login` (browser account login), not by pasting a key into Unreal.

When the three days are up, the plugin and the cfa CLI stop working and show a message to subscribe (this is different from a cancelled paid subscription, where the plugin keeps running). If you upgrade to a paid plan at any time, even before the trial ends, the same account is promoted in place to a paid plan with five machine seats and ongoing updates, so there is nothing new to paste for a normal setup. After a later cancellation, the plugin you already have keeps running and only new updates stop.

## Demos (videos)

The Demo page (https://codefizz.dev/demo) embeds short videos of the agent driving the Unreal editor by prompt, each with a plain note on what it does. They are also on the YouTube channel (https://youtube.com/@codefizz).

- A full solar system in Unreal Engine, built with Niagara by prompting (https://youtu.be/8yIMDl0NZwM). A full solar system built inside Unreal Engine with Niagara, without wiring a single node by hand. One prompt authors the entire Niagara system: the planets, their orbits, the sun, and the asteroids, all driven by user parameters so everything can be changed later. The agent starts by building the custom materials for each planet, the sun, and everything else the system needs, and when it runs into an error it asks Unreal what went wrong and fixes it on its own. It places the Niagara effect in the world, takes a screenshot, checks what looks right and what does not, and makes its own decisions from there (stopped just once to point it at the material overrides step). By the end everything is exposed as user parameters: asteroid belt radius and count, orbit tint colors, planet colors and sizes, sun glow intensity, and overall system scale, all updating automatically and drivable from gameplay at runtime.

- A fully procedural forest in Unreal Engine 5 with PCG, built by prompting (https://youtu.be/dSJUI3CMOds). A fully procedural forest built in Unreal Engine 5 using PCG, just by prompting. One prompt, and the agent builds the whole PCG graph, finds the static meshes from a marketplace asset pack by their names, and figures out where to place the rocks, trees, and foliage across the landscape. Describe the forest (big rocks, small rocks, trees, foliage) and point the agent at a marketplace asset path; it reads the meshes, decides where each one should go, and generates the graph on its own. Drop the graph into the level and scale up the PCG bounds so it covers the whole landscape. The first result has too many big rocks and no grass, so re-prompt it to reduce the rocks and spawn grass around them, and it rebuilds the graph for a far cleaner scene with full grass coverage.

- A full Unreal Engine 5 UI with zero images, only materials and AI (https://youtu.be/aSbcVre5rzk). A complete UE5 menu UI built just by prompting, with one hard rule: no images at all. Every button, panel, piece of text, and the background is made from materials only, no textures and no imported PNGs. The run builds the background material first, adds the Common Button and Common Text setup straight from the command line, pushes the background from a fractal fluid look into a real fluid simulation with an abstract shape that keeps shifting and changing color, then walks through everything the agent made: the materials, the per-state material instances for each button, the panels, the styles, and how it all wires into the main menu.

- Build Unreal Engine materials by typing a prompt (https://youtu.be/O_prPSpTO_c). Unreal Engine materials and shaders built just by typing what you want, with no manual node wiring to get started, across three live runs. First it generates an iridescent holographic material from a single prompt using custom HLSL. Then it recreates the exact same look using only raw Unreal nodes, with no HLSL at all. Last it catches a visual bug, sends the agent a screenshot, and lets it research and fix the material on its own.

## Requirements

- Unreal Engine 5.6, 5.7 or 5.8.
- Windows 64-bit. Linux and macOS are on the roadmap and will be added based on paying customer demand.
- Nothing extra for the recommended PowerShell install of the CLI. Node.js 18 or newer is only needed for the optional npm install.
- An AI tool with shell access (for the CLI) or MCP support (for the MCP server).

## How to get access (from your account)

1. Go to https://codefizz.dev/account and sign in. Four methods are supported: Continue with Google, Continue with GitHub, Continue with Discord, or email and password. Link providers on the same page so one account holds your trial or subscription.
2. Start a free 3-day trial (no credit card) or buy Pro / Patron through Polar (monthly or annual). Manage billing opens the Polar billing portal.
3. Prefer browser activation for every machine: install or update the free `cfa` CLI, then run `cfa login`. It opens the browser so you approve this machine with that same account. There is no key to copy for a normal setup, and nothing to paste inside Unreal.
4. A legacy license key still exists under a collapsed "Legacy license key" section on the account page (and optionally `cfa login --key CFA-...`) for older cfa builds, scripts, or blocked browsers. Expand that section only when you need it. Regenerating the key signs every machine out until each one logs in again.

There is no manual zip download and no key entry inside the editor. Everything below goes through the free `cfa` CLI; install it first (see "How to install the CLI").

## How to install and activate the plugin (via the cfa CLI)

1. Sign in once on this machine with browser account login: `cfa login`. Approve the device code on codefizz.dev. The editor plugin reads the same on-disk sign-in, so there is no separate in-editor activation. (Legacy alternative only: `cfa login --key CFA-...`.)
2. Install the plugin into an engine or a project: `cfa install-plugin "E:/Unreal/UE_5.8"` installs into the engine's Plugins for every project on that engine, or `cfa install-plugin "C:/MyGame"` installs into a single project. It auto-detects engine vs project and walks up if you point inside one. `cfa install-plugin --list` lists detected engines. The CLI downloads the build matching that engine for your subscription and verifies the checksum.
3. Manage versions: `cfa plugin versions` lists every available build per engine, `cfa plugin status` shows what is installed where and whether it is current (neither needs a path), and `cfa install-plugin <path> --version 1.2.0` pins or rolls back to a specific build. With no `--version` it installs the newest, so re-running updates. Add `--force` to reinstall a build you already have.
4. Update everything at once: `cfa update-all` walks every place the plugin is recorded as installed (each engine and each project) and updates them all to the newest build in one command. `cfa update-all --version 1.2.0` rolls the whole fleet back or pins it to one version, `cfa update-all --dry-run` previews the changes without touching anything, and `cfa update-all --prune` drops records whose engine or project no longer exists. Each install is reported as updated, rolled_back, reinstalled, up_to_date, skipped (target missing), pruned, or failed.
5. Remove the plugin: `cfa uninstall-plugin <path>` deletes the installed CodeFizzEditorAgent folder from that engine or project and clears the matching entry from the local install record (so `cfa plugin status` no longer lists it). It is local-only, no license check, no network, so it works even when logged out, and it leaves your other installs and the cached downloads untouched.
6. Open your project in the Unreal Editor. The CodeFizz panel reads Active automatically because it shares the CLI sign-in. The panel is read-only: license status plus a Refresh button, with Deactivate and Deactivate all devices. After activation the license is cached locally with a long offline grace (up to about 15 days between checks), so being offline or behind a firewall never blocks you.

Your paid license works on up to 5 of your own machines (a trial uses one). Manage seats from the CLI (`cfa logout` frees this machine, `cfa deactivate-all` frees every machine at once), from the editor panel, or from your account (Sign out all devices). Signing in again on the same machine never uses a second seat. The seat limit exists only to stop a license being shared publicly; honest customers never feel it. Activation and occasional re-check contact the validation server with license metadata only. No project files are sent.

## How to install the CLI (free)

Recommended: in PowerShell, run the one-line installer. It downloads the self-contained `cfa.exe` (no Node, no npm, no Python), puts it on your PATH, and offers to remove any older npm install so only one `cfa` remains:

```
irm https://codefizz.dev/install.ps1 | iex
```

From classic Command Prompt (cmd.exe), wrap it in PowerShell:

```
powershell -c "irm https://codefizz.dev/install.ps1 | iex"
```

Alternative, from npm (requires Node.js 18 or newer):

```
npm install -g codefizz-editor-agent
```

There is no Python and no config files either way. Confirm the install with `cfa --version`. Update the CLI later with `cfa self-update`, which detects how you installed it (a PowerShell install replaces itself in place, an npm install runs `npm install -g codefizz-editor-agent@latest` for you).

## How to verify

Open your project in the Unreal Editor first, because the plugin starts its local bridge when the editor launches. Then run:

```
cfa health_check
```

A healthy response means your AI tool can drive the editor.

## How to install the AI skill

The CLI bundles an Agent Skill that teaches your AI assistant how to drive Unreal through cfa: command discovery, the toolset model, workflows, and gotchas. Installing it stops the assistant from guessing commands. The skill ships inside the cfa binary, so there is nothing extra to download.

Install for all detected AI tools, globally:

```
cfa skill install
```

This auto-detects which AI tools are installed (Claude Code, Cursor, Gemini, Copilot, Windsurf, Kilo, and the cross-tool ~/.agents home) and writes the skill into each one's skills folder.

Scope and target options:

- One tool: `cfa skill install claude` (or cursor, gemini, copilot, windsurf).
- Several tools: `cfa skill install cursor gemini`.
- Every supported tool, even if not detected: `cfa skill install all --force`.
- This project only, shareable through version control: `cfa skill install claude --scope project`.
- A custom folder: `cfa skill install --dir "D:/shared/skills"`.
- Preview without writing: `cfa skill install --dry-run`.

After installing, restart your AI tool. The skill (named codefizz-editor-agent) is then discovered automatically and used whenever you work with Unreal or cfa. You can also ask for it by name. After updating the CLI with cfa self-update, re-run cfa skill install to refresh the skill in place.

## CLI vs MCP

Both interfaces talk to the same plugin. The CLI is recommended: it is direct, faster, and more token efficient for AI agents, which makes it ideal for Claude Code. Use the MCP server only when your AI tool cannot run shell commands.

- CLI usage: `cfa <command> [--flag value]`. List commands with `cfa commands`. Read one with `cfa describe <command>`.
- MCP usage: register the server automatically with `cfa install <client>`. Supported clients are claude (Claude Code), cursor, vscode (VS Code / Copilot), windsurf, gemini (Gemini CLI), jetbrains (JetBrains / Junie), zed, amazonq (Amazon Q), and codex (OpenAI Codex). Install into one (`cfa install claude`), several (`cfa install claude cursor gemini`), or every supported client at once (`cfa install all`). Use `--scope project` to write the config into the current project instead of your user config, and `--dry-run` to preview without changing anything. To configure it by hand, add an MCP server with command `cfa` and args `["mcp"]`. The same `cfa` binary serves MCP over stdio.

## Example commands

```
cfa health_check
cfa find_assets --class_type material --path /Game
cfa create_blueprint --name BP_Spawner --path /Game/BP --parent-class Actor
cfa create_event_dispatcher --blueprint-path /Game/BP/BP_Spawner --name OnSpawned
cfa build_material_graph --json '{"material_path":"/Game/M_Test","nodes":[]}'
```

## Working with more than one editor open

Every cfa command targets exactly one running editor. With several editors open, the CLI routes by an explicit selection and refuses to guess, so it never edits the wrong project.

- cfa list_editors: list every running editor with its project name, .uproject path, engine version, process id, and bridge port.
- cfa connect <project>: choose one editor for the commands that follow. The selection is saved on disk, so it carries across separate terminals (useful for AI agents that run each command in a fresh shell). Connect by project name (for example cfa connect jiggi) or by --port.
- cfa disconnect: clear the selection.
- cfa status: show the running editors, the current selection, and which editor a command would hit right now, or why it would refuse.

If the choice is ambiguous, the command returns an error that lists the running editors instead of acting. With a single editor open, or when your terminal sits inside the project folder, routing is automatic. cfa health_check also reports the editor it reached (project, engine version, process id, and port) so you can confirm you are on the right one. For two AI agents driving two editors at once, set the CFA_SESSION environment variable to a per-agent name (for example CFA_SESSION=agentA) so their selections never collide.

## CLI command reference (setup and management)

These are the commands for licensing, installing, and managing the plugin and the MCP server. The ~500 editor commands (spawn_actor, build_material_graph, and so on) are separate and listed on the Tools page; discover them with `cfa commands`, `cfa search <query>`, and `cfa describe <command>`.

Licensing and account:
- `cfa login`, recommended. Opens the browser so you sign in with your CodeFizz account (Firebase on codefizz.dev) and activate this machine. The editor plugin reads the same sign-in.
- `cfa login --key CFA-XXXX-XXXX-XXXX-XXXX`, legacy only. Optional key paste for older cfa builds or blocked browsers.
- `cfa logout`, deactivate this machine's seat and remove the local license.
- `cfa deactivate-all`, free every seat across all machines at once, then remove the local license. Run `cfa login` again afterward.
- `cfa whoami`, show the current license status (email, expiry, machine fingerprint).

Plugin install and updates:
- `cfa install-plugin <path>`, download and install the plugin into an engine (a folder with Engine/Build/Build.version) or a project (a folder with a .uproject). Flags: `--version <v>` (install or roll back to a specific build), `--list` (list detected engines and exit), `--force` (reinstall even if current), `--engine 5.8` (engine version for a source-build project whose .uproject has no plain version).
- `cfa uninstall-plugin <path>`, remove the plugin from that engine or project (local-only, no login needed).
- `cfa update-all`, update (or roll back) every recorded install in one go. Flags: `--version <v>`, `--force`, `--dry-run`, `--prune`.
- `cfa plugin versions`, list every available build per engine for your subscription.
- `cfa plugin status`, show where the plugin is installed and which version, and whether each is current.

MCP server and AI tools:
- `cfa install <client...>`, register the cfa MCP server into AI tools (claude, cursor, vscode, windsurf, gemini, jetbrains, zed, amazonq, codex, or `all`). Flags include `--scope user|project` and `--dry-run`.
- `cfa skill install`, install the bundled Agent Skill that teaches your AI assistant how to use cfa.
- `cfa mcp`, run as an MCP server over stdio (this is what AI tools launch; config entry is command `cfa`, args `["mcp"]`).

Editor connection and diagnostics:
- `cfa health_check`, confirm the editor bridge is reachable; reports the editor it reached (project, engine, pid, port).
- `cfa list_editors` / `cfa connect <project>` / `cfa disconnect` / `cfa status`, route commands when several editors are open.
- `cfa doctor`, diagnose the setup (finds the .uproject, the plugin entry, the bridge file, the TCP connection, and runs a health check).
- `cfa commands` / `cfa search <query>` / `cfa describe <command>`, discover and read the editor commands.

## Tool categories (21, over 600 commands)

- Niagara: full FX control. Emitters, modules, scratch pad, simulation stages, renderers, custom HLSL, parameter wiring, validation.
- PCG: procedural content generation. Graphs, nodes, edges, runtime generation, partition inspection, compute sources, subgraphs, validation.
- Materials: material graphs, instances, functions, function instances, material layers, and parameter collections. Build expressions, connect pins, set parameters, trace connections, validate, and apply materials to actors.
- StateTree: author StateTree assets. States, transitions, tasks, evaluators, conditions, global tasks, parameters, bindings, compilation.
- Sequencer: author Level Sequences end to end. Create sequences and cameras, bind actors as possessables or spawnables, add transform, property, audio, and skeletal animation tracks, keyframe any channel with interpolation and tangents, add camera cuts, subsequences, marked frames, and folders, then render to video through the Movie Render Queue.
- Level Actors: spawn, find, select, transform, and delete actors, and place or revert a whole layout in one call. Read and write any reflected property, frame the viewport, screenshot, and start or stop Play In Editor. Create, open, and save levels, drop a full lighting rig with presets (clear, noon, sunset, overcast, snowy, night), read a mesh true bounds and pivot, and read a level as a compact clustered scene map.
- Project Settings: read and edit any Project or Editor setting through reflection. Search for a settings section, read its properties and valid values, and change one or many, saved to the right Default config file (DefaultEngine.ini, DefaultGame.ini). Add collision channels and presets, set default maps and game modes, and define console variables. Errors name the class an option needs or list the valid enum values.
- Blueprints: create Blueprints from any parent class. Add and edit variables, local variables, functions, event graphs, event dispatchers, and components. Build and wire graph nodes, set class defaults, compile, inspect, and export to readable text.
- Blueprint Structs: author UserDefinedStruct assets with typed members.
- Enhanced Input: author Input Actions and Mapping Contexts. Configure triggers, modifiers, and key mappings.
- Asset Management: find, list, import, save, duplicate, rename, and delete assets. Read metadata and properties.
- Bulk Asset Ops: batch move, rename, and delete assets with automatic reference repointing.
- Data Assets: create UDataAsset instances and discover their classes and valid property types.
- Object Properties: read and write nested properties on any UObject by dotted or indexed path.
- UMG Widgets: create Widget Blueprints and build the full widget tree. Wire named slots, navigation, property bindings, widget animations, and MVVM viewmodels.
- Data Tables: read, add, update, delete, duplicate, and rename data table rows.
- Curves: author Curve assets, Curve Tables, and Curve Atlases. Set float, vector, and color curve keys with per key interpolation, tangent modes, and extrapolation, evaluate a curve at any time, edit table rows, and build atlases that refresh the materials using them.
- Console Commands: list, inspect, and execute console commands and cvars.
- Profiling: capture and analyze Unreal Insights traces, pick trace channels, add bookmarks and snapshots, find worst frames, drill into timer stats, or read a live in-editor sampler.
- Core: health check and core editor utilities.
- Debug: MCP debug controls and telemetry.

The full searchable command list is on the Tools page at https://codefizz.dev/tools.

## Pricing

This is a one-developer project. A subscription funds continued development as much as it grants access: new features, fixes, and whatever the roadmap votes up next. Subscribing is what keeps the updates coming.

- Pro: 19.99 USD per month. Includes the full plugin (UE 5.6, 5.7 and 5.8, Win64), all future updates while subscribed, Pro Discord channel access, priority bug reports, and a monthly dev log.
- Patron: 35.99 USD per month. Includes everything in Pro plus roadmap voting (5x weighted), a private 90 day roadmap board, priority DM support (24h response), direct input on new API design, a founding Patron Discord badge, and a price that is locked while you stay subscribed.

Payments are processed by Polar, the Merchant of Record. Manage or cancel your subscription anytime from your account at https://codefizz.dev/account (the Manage billing button opens the Polar billing portal). After cancellation the plugin you already have keeps running, so honest customers are never cut off. You stop receiving new updates and lose subscriber perks like Discord roles and roadmap voting. A license found shared publicly may be revoked.

## Frequently asked questions

Q: Which Unreal Engine versions are supported?
A: UE 5.6, 5.7 and 5.8 on Win64. Each release ships as a separate binary plugin matched to the engine ABI. Future engine versions will be added as they release.

Q: Which platforms are supported?
A: Windows 64-bit only for this first release. Linux and macOS support are on the roadmap and will be added when there is clear demand from paying customers.

Q: Do I need to activate a license?
A: Yes, once per machine, from the CLI, not inside the editor. Run `cfa login`. It opens your browser so you sign in with the same CodeFizz account you use on the website. That activates the machine; the editor plugin reads the same sign-in and shows Active with nothing to paste. Offline grace still applies. A legacy key path (`cfa login --key`) still exists but is optional and hidden behind a collapsed control on the account page.

Q: How many computers can I use my license on?
A: Up to 5 of your own machines on a paid plan (a trial is one machine). Manage seats with `cfa logout`, `cfa deactivate-all`, the editor panel, or Sign out all devices on the account page. Signing in again on the same machine never uses a second seat. The limit exists only to stop public sharing; honest customers never feel it.

Q: How do I activate the plugin in the editor?
A: You do not activate it inside the editor. Install cfa, run `cfa login`, approve the browser step, then open your project. The CodeFizz panel is read-only (status, Refresh, deactivate actions).

Q: How do I sign in to my account, and which sign-in methods are supported?
A: Go to https://codefizz.dev/account. Four methods are supported: Continue with Google, Continue with GitHub, Continue with Discord, or email and password. Link providers so all sign-ins reach one account for trial, billing, and CLI browser login.

Q: Do I need to copy a license key?
A: No for a normal setup. Prefer `cfa login` with your website account. If you already have a subscription or trial, the account page focuses on activating with the CLI. A legacy key is available only under the collapsed "Legacy license key" section for older builds and recovery.

Q: Can I regenerate my key or sign out all my devices?
A: Sign out all devices from the account page or with `cfa deactivate-all`. Regenerate key (under the collapsed legacy key section) issues a new key and retires the old one if a key leaked; then run `cfa login` again on each machine (browser path preferred).

Q: I have more than one Unreal editor open. Which one does cfa control?
A: Each command talks to exactly one editor. Run cfa list_editors to see every running editor with its project, engine, port, and process id, then cfa connect <project> to choose one for the commands that follow. The selection carries across separate terminals. If the choice is ambiguous, the CLI refuses and lists the editors instead of editing the wrong project. With a single editor open, or when your terminal is inside the project folder, it routes automatically. cfa health_check also reports which editor it reached.

Q: Is there a free version?
A: Yes. The open-source community edition (Unreal MCP) gives you the core bridge and a basic command set, which is great for trying the workflow. Pro is the fully maintained build with the complete toolset, regular updates, and support.

Q: What MCP clients work with the plugin?
A: Any MCP-compatible client. The plugin exposes a TCP bridge and the CLI ships separately, so Claude Code, Cursor, VS Code, Gemini, and other MCP hosts all work.

Q: Should I use the CLI or the MCP server?
A: Prefer the CLI. It talks directly to the plugin and is faster and more token efficient for AI agents. Use MCP only when your AI tool cannot run shell commands.

Q: Can I cancel anytime?
A: Yes. Open your account at https://codefizz.dev/account and click Manage billing to open the Polar billing portal, then cancel in one click. You keep access through the end of your billing period.

Q: What happens to my downloaded plugin if I cancel?
A: You keep the version you downloaded and it keeps working, because your license stays valid after you cancel. You stop receiving new releases and lose access to the private Discord and roadmap.

Q: Do you offer refunds?
A: No refunds on subscriptions, since the plugin is downloadable software you get immediately. You can cancel anytime and keep access through the end of the paid period. For a real bug or a reasonably expected missing feature, contact support.

Q: Why is Patron more expensive when I get the same plugin?
A: Patron is for people who want to influence the direction of the product, with voting, a private roadmap, priority answers, and direct input on new APIs. If you just need the plugin and updates, Pro is enough.

Q: Studio or team licensing?
A: For studios needing multiple seats, an enterprise tier is available off-platform. Contact directly for pricing.

## Troubleshooting

Plugin fails to load on Unreal Engine 5.8 (GetLastError=126): The editor stops at startup with "Plugin 'CodeFizzEditorAgent' failed to load because module 'CodeFizzEditorAgent' could not be loaded", and the log reports "Failed to load UnrealEditor-CodeFizzEditorAgent.dll (GetLastError=126)" with a missing UnrealEditor-WorldStreamingInsights.dll, even though that DLL exists on disk. This was a packaging bug in plugin builds before 1.2.44, seen mainly on UE 5.8 projects opened with the launcher-installed engine (including Blueprint-only projects). It is not a problem with your engine install, Visual Studio, redistributables, or BuildId, so reinstalling the engine does not help. Fix: update the plugin to 1.2.44 or newer. Close the Unreal Editor first (the plugin file is locked while it runs), then run `cfa update-all` to update every install, or `cfa install-plugin "C:/Program Files/Epic Games/UE_5.8"` to reinstall the newest build for that engine, and reopen your project. Details: https://codefizz.dev/docs/troubleshooting

Bridge unreachable: A command reports the bridge is unreachable when the editor is not running or the plugin is not enabled. Open your project in the Unreal Editor, enable the plugin if prompted, and run `cfa health_check` to confirm which editor you reached.

Wrong editor targeted: If a change landed in the wrong project, more than one editor is open. Run `cfa list_editors`, then `cfa connect <project>` to choose the one you mean.

Plugin shows inactive in the editor panel: The plugin reads the same sign-in as the CLI, so there is nothing to paste in Unreal. Sign in on this machine with `cfa login`, press Refresh in the CodeFizz panel, and check status with `cfa whoami`.

Plugin version mismatch or odd behavior after an update: Run `cfa plugin status` to see what is installed where, then `cfa update-all` to move every install to the newest build (or `cfa install-plugin <path> --version x.y.z` to pin or roll back a specific build).

Still stuck: email contact@codefizz.dev with the command you ran and its output.

<!-- CHANGELOG:START (generated by scripts/gen-changelog-llms.mjs) -->
## Changelog (release history)

Two version lines, newest first: the Unreal Engine plugin (CodeFizz Editor Agent) and the cfa CLI (codefizz-editor-agent). The plugin descriptor tracks the editor and packaging side; the CLI is where the tool and command work is versioned. Full page: https://codefizz.dev/changelog

### Plugin (CodeFizz Editor Agent)

**v1.2.44** Fixes the plugin failing to load on Unreal 5.8 with a "module could not be loaded" error (GetLastError 126) on projects opened with the stock launcher engine.
- Changed: The four Insights profiling backends (World Streaming, Render Trace, IoStore, and Chaos locks) are read on demand instead of being linked into the plugin. The matching profiling queries still work when those engine plugins are enabled, and just return a short "enable this plugin" note when they are not, rather than ever stopping the editor from opening. Verified opening cleanly on 5.6, 5.7, and 5.8.
- Fixed: The plugin no longer fails to load on Unreal 5.8. On projects opened with the launcher-installed engine, the editor could stop at startup with "Plugin CodeFizzEditorAgent failed to load because module could not be loaded", pointing at a missing WorldStreamingInsights import even though that file was present. The cause was that the plugin hard-linked a couple of experimental profiling plugins that ship turned off in the stock editor, so their DLLs were never on the load path. It now reads those profiling providers without linking their DLLs at all, so there is nothing left to go missing.

**v1.2.43** Materials get a production pass: build a whole material function in one call, errors that name the valid pins and types, smarter pin matching, cleaner auto layout, and richer JSON export for functions and function instances.
- Added: Material functions are ready to compile the moment you make one. Every new function comes with its output node already in place (the same one the editor adds on first open), so there is no more reading it, deleting it, and recreating it. If you build a function graph without an output, one is created for you and reported back.
- Added: Connections can target a function's output or a named input directly. Write "output", "output:Name", or "input:Name" in a connection instead of hunting for the node index.
- Added: Material function interface and comments are now in the JSON export, and material function instances export as a first class asset with their parent and overrides. So you can read any material, function, instance, or function instance as text and see everything about it.
- Changed: Building a material or material function checks every node type before it touches the existing graph, so a typo can never wipe a graph you meant to keep.
- Changed: Pin names match more forgivingly. Writing "Position" connects to a node's "World Position" pin and "Coordinates" connects to a texture sample's UVs, while a genuinely ambiguous name still stops and lists the choices.
- Changed: Reading a material function is adjustable now: ask for just the interface, a summary with node counts, or the full node list, so you only pull what you need.
- Changed: Auto layout keeps the final output node on the right, gives each unconnected branch its own row, and parks stray nodes off to the side, so a laid out graph reads cleanly.
- Fixed: Assigning the wrong type to a material property or a function input returns a clear error listing the valid values, instead of silently accepting a wrong default.
- Fixed: A failed connection tells you exactly which input pins are valid on the target node, so you fix it in one step instead of guessing.

**v1.2.42** The profiling system grows up: thirteen new analysis queries reaching into memory callstacks, per actor network bandwidth, Mass ECS, animation, and physics, plus a long list of hardening fixes so every query is safe to run and every error tells you what to do next.
- Added: Allocation history queries (alloc_query). Ask questions like "which callstacks hold the most live memory" or "what was allocated between these two bookmarks and never freed", the same investigation Unreal Insights does in its memory tab. Results group by callstack with resolved function names when the trace was recorded with callstacks.
- Added: Per actor network bandwidth (net_objects) and per packet detail (net_packets). See exactly which replicated actors eat your bandwidth, packet sizes over time, bursts, and drops. Built for multiplayer tuning.
- Added: Mass ECS profiling (mass). Fragment and tag registry with sizes, entities created and destroyed over time, archetype churn, and processing phase timings, read straight from the Mass trace channel on both 5.7 and 5.8.
- Added: Skeletal animation profiling (animation). List every animated object in a trace, then drill into blend weights per asset, anim graph phase cost, notifies, and montage playback.
- Added: More new queries: memory_series (one memory tag over time with start to end delta), stack_tree (a weighted call tree from CPU samples), cook (per package cook timings), iostore (pak reads per package), chaos_locks (physics lock contention), world_streaming (World Partition cell churn, 5.8), render_trace (RDG pass pipeline, 5.8), and trace_channels (which channels a trace actually recorded, the first thing to check when a query comes back empty).
- Changed: Every list a query returns is now capped with a clear "showing X of Y" note, so a trace with two thousand counters can never flood the output. Errors name valid alternatives: a wrong category lists the categories, a wrong thread lists real thread names, an unknown query lists every query.
- Changed: Queries that target a frame (hotpath, compare, frame_details, inspect_frame) now default to the worst frame instead of failing when no frame index is given.
- Fixed: The loading and file_io queries never returned data because the engine ships their analysis module disabled. It is now enabled, so asset loading and disk activity work out of the box. The same fix covers cook.
- Fixed: Asking for a call tree of a timer that exists but never ran used to return an empty tree full of zeros, which read like "this costs nothing". It now says the matched timer has no recorded instances and lists similar timer names that do.
- Fixed: A crash inside Unreal 5.8 itself: analyzing a mid session trace that contains rendertrace data asserts in the engine and takes the whole editor down. The plugin now keeps that analyzer off by default so loading any trace is safe, and render_trace explains how to opt in for traces recorded from startup.
- Fixed: Memory leak checks no longer give a false all clear when LLM was not running, network stats no longer return an empty success when there is no network data, and a dozen smaller cases where an empty result looked like a real answer now explain what was missing and how to record it.

**v1.2.41** Full support for curve assets: float, vector, and color curves, curve tables, and curve atlases, all created and edited straight from the editor with careful protection against bad input.
- Added: Create and edit Curve assets: float, vector (x, y, z), and linear color (r, g, b, a). You can set every key the way the curve editor does, with per key interpolation (cubic, linear, constant), tangent modes (auto, smart auto, user, break) and explicit tangent slopes, weighted tangents, pre and post infinity extrapolation, and a default value. You can also merge keys into an existing curve, delete keys by time or clear them, and evaluate the curve at any time to check the result.
- Added: Create and edit Curve Tables, including Composite Curve Tables that stack other tables. Add, update, delete, and rename rows, with rich curves (per key interpolation) or simple curves (one interpolation per row). Read any row back with its keys and evaluated values, or export the whole table.
- Added: Create and edit Curve Atlases from linear color curves, with resize, add, remove, and replace. The atlas texture rebuilds and any materials using it refresh automatically, just like editing it by hand.
- Added: Full fidelity import and export. Read a curve or table as the engine's own JSON and re import it exactly, or work in plain CSV. Ease Curve Libraries are supported too (on the engine versions that ship them).
- Fixed: Bad input can no longer corrupt your data. Every value in a request is checked before anything is written, so a typo in one key never leaves a curve half rewritten, and an import that fails restores the previous data instead of clearing it. Oversized atlas sizes, reserved row names, and JSON from the wrong curve type are all caught with a clear message, and the editor is never left in a bad state.

**v1.2.40** Blueprint Interfaces and Function Libraries land, every function property is now editable, and graph auto layout routes wires much more cleanly.
- Added: Full Blueprint Interface support. Create an interface asset, add its functions the same way you add any function, implement the interface on any Blueprint class, list what a Blueprint implements, and remove an interface again (optionally keeping its generated functions as normal ones). When you implement an interface, the response tells you exactly what to do next for each function: void functions become placeable event nodes, and functions with a return value arrive as ready-made function graphs.
- Added: Two new graph node kinds for interfaces. interface_event places the event for an implemented interface function, and interface_call places a message call that invokes an interface function on any object, safely doing nothing at runtime if the target does not implement it.
- Added: Blueprint Function Libraries. Create a library asset whose functions compile as static and can be called from any Blueprint in the project.
- Added: A new set_function_properties command that edits any function the way the Details panel does: pure, const, exec, access specifier (public, protected, private), category, tooltip, keywords, and every editor metadata field such as compact node title, call in editor, thread safe, and deprecation. The same options can be passed when creating a function, and function details read all of it back.
- Added: A reparent_blueprint command that changes a Blueprint class parent, refreshes every node, recompiles, and reports the real compile diagnostics.
- Changed: Graph auto layout places far fewer reroute knots and routes them much more intelligently. Wires fanning out from one pin now share a single clean bus instead of stacking a pile of knots, loop wires travel on one clear lane above everything they cross, short backwards wires stay as normal splines instead of circling the whole graph, and knots no longer land on top of nodes. Re-running the arrange command stays stable instead of accumulating knots.
- Changed: Graph analysis now reports when a node is Development Only or disabled, so an agent reading the graph sees the same state you see in the editor.
- Fixed: Nodes for development-only functions such as Print String now show their Development Only banner the moment they are placed. Before, the banner only appeared after restarting the editor.
- Fixed: A failed graph build could delete a function entry or return node while rolling back, leaving the function gutted. Rollback now never touches nodes that already existed before the build.
- Fixed: Creating a function with a return type silently produced a void function. The requested return value is now actually applied.
- Fixed: Function graphs created by implementing an interface were invisible to graph targeting, analysis, and function details. They now resolve everywhere a normal function does.
- Fixed: Closing the editor or deleting an asset while a Blueprint graph right-click menu was open could crash the editor. Open menus are now dismissed first, and deleting an asset closes any editor that has it open.

**v1.2.39** Right-click any asset in the Content Browser and export it to JSON. One click writes the asset as reflection JSON to your Saved folder and opens the folder for you.
- Added: A new Export to JSON (CodeFizz) item in the Content Browser right-click menu. Select one or more assets, and it writes each one as reflection JSON into Saved/CodeFizzEditorAgent/Exports, then opens that folder. It produces the same complete export the export_asset command does, so Blueprints, materials, PCG graphs, data tables, textures, and any other asset are all covered, with a human readable text version written alongside the JSON. Selecting several assets exports each of them and opens the Exports folder once. A short notification tells you how many were written. Both the plugin and the CLI take the exact same export path, so what you get from the right-click matches what an agent gets from the command. It works the same on Unreal 5.6, 5.7, and 5.8.

**v1.2.38** License messages in the editor now point at browser account login. Run cfa login, sign in on the website, then click Refresh. No key paste in the editor.
- Changed: When the plugin is not licensed, the Settings license panel tells you to run cfa login from the terminal. That opens your browser so you can sign in with your CodeFizz account, then click Refresh in the panel. The shared license file is the same as before, so once the CLI has activated this machine the editor picks it up without pasting a key.
- Changed: Status messages for offline grace end, revoked keys, deactivated machines, machine mismatch, seat limits, and missing trials or subscriptions all say cfa login (browser) instead of cfa login --key. You can still use a key with the CLI if you need to, but the default path is account sign in.

**v1.2.37** Materials are now first class from the tool. Read the material slots of any mesh and assign materials per slot, on placed actors and on Blueprint component defaults alike, and property edits show in the viewport right away.
- Added: A new command to read material slots. Point it at a placed actor, a Blueprint, or a static mesh asset and it lists every mesh component and each of its element slots, with the slot name, the material currently on it, and whether that slot is an instance override or the mesh default. It works the same for static, skeletal, and instanced meshes, so you can see exactly what a model exposes before you change anything.
- Added: A new command to assign materials by slot, one target or many in a single call. Set a material on a specific slot, by slot name, or on every slot at once, on a single actor, on all actors matching a name prefix, or on a Blueprint component default. Setting it on a Blueprint applies to the class defaults and carries through to the instances you place, and you can still override an individual placed actor afterward. Pass an empty material to clear a slot back to the mesh default. A wrong slot is refused with the valid slot indices and names, so a mistake tells you how to fix it.
- Fixed: Setting a property on a placed actor now updates the viewport immediately. Before, changing something like a component material through set_actor_property saved the value but the change did not show until the component was touched again, because the edit did not refresh the render state. It now runs the same pre and post edit path the Details panel uses, so the change appears at once.
- Fixed: The default scene lighting no longer triggers the on screen warning about cached lighting being clipped. When a lighting preset uses a strong manual exposure, the tool now matches the cached lighting pre exposure to that exposure, so Lumen and the real time sky capture stay in range and the red warning does not appear.

**v1.2.36** The editor agent no longer pulls its editor only tools into your packaged game. It is an editor tool, so its plugin dependencies are now scoped to editor builds and are left out of shipping builds.
- Fixed: The plugin now marks its dependencies (Movie Render Pipeline, the Python plugin, and the other plugins it uses only inside the editor) as editor only, so enabling the editor agent no longer forces them into a packaged game. Before, because the dependency list had no target restriction, installing this editor tool quietly enabled its editor dependencies, and their runtime modules, for game builds too, so they ended up compiled into shipping builds. The editor module itself was always editor only, this closes the remaining path where the dependencies leaked. Plugins your own project uses, like Enhanced Input, Niagara, PCG, or StateTree, are unaffected. They stay in your game because your project enables them, not because of this tool.

**v1.2.35** Author and render cinematics from the command line. A full Sequencer command family builds a Level Sequence end to end, animates it with keyframes, points a camera at it, and renders it to an image sequence, and it now works the same on Unreal 5.6, 5.7, and 5.8.
- Added: A complete Sequencer command family (about 65 commands) to build and render cinematics without opening the Sequencer panel. Create a Level Sequence, set its rate and playback range, add bindings, add tracks and sections, keyframe transforms and properties, add a camera and a camera cut, then render the shot through Movie Render Queue to a PNG sequence you can encode to video. Every step is addressable and queryable, so you can read a binding, evaluate the animated value at any frame, and scrub the timeline.
- Added: Self contained sequences using spawnables. Bake a configured object (a light, a mesh, a camera) into the sequence as a spawnable, and it spawns its own content in any level, so what you see when you scrub matches what the render produces, with no missing or red bindings. This is the recommended way to build a demo or a showcase that stays consistent and shippable.
- Added: Rich animation: keyframe a light color and intensity through a component binding, play an animation on a skeletal mesh, animate transforms, and shape the curves with interpolation, tangents, and extrapolation. Plus audio tracks, subsequences, folders, timeline markers, and a global time warp on 5.8.
- Added: Wrong operations are rejected with the valid options instead of failing quietly. Adding a skeletal animation to a light is refused by name, a mistyped property suggests the closest match, a bad channel lists the valid channels, and a component that does not exist lists the ones that do. So a mistake tells you how to fix it.
- Fixed: The plugin now packages cleanly on Unreal 5.6. The Sequencer commands were rebuilt on the core Movie Scene modules so they no longer depend on editor only modules that are not available to link in the installed 5.6 engine, which previously failed the 5.6 package with unresolved symbols. All three engines, 5.6, 5.7, and 5.8, now build and behave the same.

**v1.2.34** Safer project settings edits: assigning a class or asset that does not exist, or that is the wrong type, is now caught with a clear error, and a Blueprint class is stored in the correct form.
- Changed: Class settings now say clearly whether a value could not be found or is the wrong type, and asset settings point you at find_assets to locate a valid one.
- Fixed: Assigning a Blueprint class to a class setting like the Game Instance class or the Default Game Mode now stores the generated class path (the one with the _C suffix), the same value the editor stores. Before, passing the plain Blueprint asset path saved a reference that does not resolve to a class at runtime. You can pass it with or without the _C now, either way it is stored correctly.
- Fixed: Assigning a map or asset that does not exist to a setting like the Game Default Map is now rejected with a clear error, instead of being accepted silently and failing to load at runtime. Assigning an asset of the wrong type, for example a Blueprint where a World is required, is rejected too, matching what the settings picker allows.

**v1.2.33** Read and edit any Project or Editor setting from the command line through reflection, and have it written to the right Default config file exactly the way the editor Project Settings window does.
- Added: Three new commands, search_project_settings, get_project_settings, and set_project_settings, drive the whole Project Settings tree. Search finds the section you mean and tells you which Default config file it writes to, get returns every property with its current value and what it accepts, and set changes one property or a batch and then saves it to the correct file, DefaultEngine.ini, DefaultGame.ini, and so on. It goes through Unreal own settings registry and property reflection, so nothing is hardcoded per setting, and Maps and Modes, Collision, Rendering, Asset Manager, Data Driven CVars, and any custom developer settings all work the same way. Console variable backed settings save under their real variable name, the same as the editor.
- Added: Full collision setup from the terminal: add object channels and trace channels, add collision presets, and edit a preset responses, for example set the Camera response on a preset to Block or Ignore. Everything is written to the config and is live in the editor, so a new channel or preset shows up in the collision dropdowns without a restart.
- Added: Errors tell you what a property actually wants. Assign the wrong class to a class property, like a Character where a Game Instance is required, and it names the base class it needs. Give an enum value that does not exist, even one nested inside a struct, and it lists the valid values. Mistype a property name and it suggests the closest matches.
- Changed: Settings edits now fire the same change notification the editor details panel uses, so a setting rebuilds its state exactly like a manual edit. Settings are also reachable by class name even when their Project Settings page has not been opened yet, so a section that registers late is never missed.

**v1.2.32** Level lifecycle and lighting from the command line: create, open, and save a level, read the New Level templates, and drop a full lighting setup in one call with physically grounded presets for clear, noon, sunset, overcast, snowy, and night.
- Added: create_level makes and opens a level, either blank, a World Partition open world, or from a template like Basic or Open World. open_level opens an existing map, save_level and save_level_as write it, and list_level_templates returns the same entries the editor New Level dialog shows with their real template map paths. These mirror Unreal own level tools, so nothing is hand rolled. Creating or saving rejects engine and other read only paths so a map cannot land in the wrong place, and opening a map that does not exist reports a clear error instead of silently doing nothing.
- Added: setup_default_scene drops a ready to light environment into the current level in one call: the sun as an atmosphere light, a sky atmosphere, a real time capture sky light, height fog, and a floor, all filed under an Environment folder, so a fresh empty map is viewable right away. Options add volumetric clouds, an unbound post process volume, and a player start.
- Added: setup_default_scene takes a preset, clear, noon, sunset, overcast, snowy, or night, and applies a physically grounded grade on top of the rig. Each preset sets the sun angle and a real world intensity in lux, the sky atmosphere and fog, and a fixed manual exposure on the post process volume, so the look is the same in any project and nothing in the project settings is touched. It follows Unreal own outdoor lighting rules, a neutral light temperature that does not fight the sky color, subtle fog, and cloud coverage driven from the cloud material instance rather than reinvented.

**v1.2.31** A set of level design commands: place a whole layout at once, understand a level as a compact clustered summary instead of a giant actor list, read a mesh true shape before placing it, aim the viewport from any angle, and organize the outliner with folders, groups, and parent-child attachment.
- Added: get_mesh_info reads a static mesh asset native bounds, its pivot offset (where the pivot sits relative to the mesh, so you know if it is centered or at a corner), and its real collision shape (convex hulls with vertex counts, boxes, spheres, capsules), plus sockets and vertex, triangle, LOD, and material counts. So a wedge reads as a wedge and placement is planned from the mesh true size and pivot rather than guessed.
- Added: spawn_actors_batch places a whole computed layout, hundreds to thousands of actors, in one call and one undo step, caching each mesh so a shared-mesh batch loads it once. delete_actors_batch removes a batch by name prefix or list, so a layout can be reverted in a single call.
- Added: get_scene_map now returns a clustered, context-friendly summary of the level instead of a flat per-actor dump. Actors are grouped by mesh into spatial structures, each tagged with its arrangement (grid, ring, line, or scattered), count, bounds, and outliner folder, with an ASCII density map of the whole level, and a drill option to page through one cluster raw actors. It scales from a handful of actors to very large levels without flooding the reader, and a label filter isolates a group you placed.
- Added: capture_top_down renders an orthographic floor plan of the level to a PNG off screen, auto fitting to the placed content and dropping atmosphere and fog, which reads a layout far more clearly than a perspective screenshot.
- Added: focus_viewport can frame an actor from a chosen direction (top, bottom, front, back, left, right, iso, or an exact pitch and yaw) at a set distance or fill fraction, not just the default framing.
- Added: Outliner organization and hierarchy: move actors into folders and create, rename, delete, and list folders, group and ungroup actors, and attach or detach actors as a parent-child transform hierarchy so moving the parent moves the children. The folder commands resolve a folder real identity on World Partition maps, so they remove and rename correctly there.

**v1.2.30** A new export_statetree command writes a whole StateTree to one JSON file, everything about how it runs in one place, and the Blueprint export now includes the class defaults a Blueprint overrides, so a character export shows its AI controller and a controller export shows the StateTree its component runs.
- Added: export_statetree writes a full JSON export of a StateTree. It captures the schema, the theme colors, the tree parameters with their values, and the whole state hierarchy, and for every task, condition, evaluator, consideration, and global task it records whether the node is C++ or Blueprint, its C++ struct path or its Blueprint asset path, the values on it, and the property bindings feeding it (both on the node itself and as a full binding table).
- Added: Every state in the export carries its resolved color (display name, RGBA, and hex), its type, selection behavior, tag, and description, and its full transitions with their triggers, priorities, delays, target states, and the conditions on each one.
- Added: The Blueprint export has a new class defaults section that lists the inherited properties a Blueprint overrides, like a character Auto Possess AI and AI Controller Class, so cross references between assets are visible: a character points at its controller, and a controller StateTree component points at the tree it runs.
- Changed: StateTree reads now report each node identity: whether it is a C++ or a Blueprint node, the C++ struct path, and for a Blueprint node the asset path and its exposed pins, so it is clear what every task and condition actually is and where it comes from.

**v1.2.29** You can now author a complete StateTree AI from the command line, the custom Blueprint task and condition nodes, the tree with its parameters and bindings, and assigning it to a component, plus a new command that sets properties on a Blueprint component template, which the class defaults could not reach.
- Added: set_blueprint_component_property sets a property on a component inside a Blueprint (the ones in the Components panel), both components added in the editor and native C++ ones. It reaches things set_blueprint_class_defaults cannot, like the mesh on a Static Mesh Component, takes a single property or a batch, and recompiles so already placed instances pick up the new default.
- Added: override_blueprint_function implements a parent class event or function the way the My Blueprint Override menu does. A plain event becomes an event node, and one that returns a value (like a StateTree test condition) becomes a function graph with the entry and result nodes ready to wire.
- Added: Tree parameters can carry a value now. add_statetree_parameter takes a value, and a new set_statetree_parameter updates one later, so a global like a sight range or a speed is a real number instead of being stuck at zero.
- Added: add_component_to_blueprint can set initial property values on the new component in the same call.
- Changed: set_statetree_component_tree assigns a StateTree to a StateTree or AI component, on a placed actor or on a Blueprint, syncs the parameter values, and reports the tree schema so a mismatch shows up right away.
- Changed: set_statetree_node_property can write the values on a Blueprint task or condition node, so a custom node can be configured differently at each place it is used.
- Fixed: create_blueprint saves the new asset right away, so a freshly created Blueprint is not lost if the editor closes before the next save.

**v1.2.28** A new export_niagara command writes a whole Niagara system, or a single module, dynamic input, function script, or emitter, to one JSON file. It is the fastest way to read and understand an effect, everything in one place grounded in the engine reflection, instead of clicking through the editor or running a dozen separate queries.
- Added: export_niagara writes a full JSON export of any Niagara asset. For a system it captures the system properties, the user parameters with their default values, every emitter (its properties, renderers, and the ordered module stack of each stage), and the values set on every module input. It auto-detects whether you point it at a system, a module or dynamic input or function script, or an emitter.
- Added: The full module screen is exported for every script, the category, the module usage bitmask (with the usage flags spelled out), the library visibility (exposed, unexposed, or hidden), the suggested flag, the provided and required dependencies, the note message, the description, the keywords, and the numeric output selection mode. The module inputs and outputs are listed as a clean contract as well.
- Added: Dynamic inputs are captured at the place they are used, showing which dynamic input it is (name and path), what type it outputs, and the values set on its own inputs, including nested dynamic inputs. Scratch pad and other in system local scripts are exported in full with their node graph and their custom HLSL.
- Changed: Modules and dynamic inputs that live as their own asset (the engine ones or your own) are referenced by path with their description and their input and output contract, rather than copying the full node graph into every place they are used. That keeps a system export small (around a megabyte instead of six) while still saying exactly what is used and where, and you can export any of those assets on its own to see the internals.

**v1.2.27** Niagara authoring, revamped. Building an effect from nothing (custom script modules, dynamic inputs, emitters, renderers) is now reliable end to end: scripts compile and apply themselves, values you set actually stick, and the two most common ways a generated script can fail to compile are caught up front.
- Added: build_niagara_graph now finalizes the script for you. After building the node graph it compiles and applies the module, dynamic input, or function in the same call, so the script is immediately usable in an emitter stack instead of sitting there uncompiled. You can turn it off per call if you want to batch.
- Added: Guardrails for the two HLSL mistakes that used to fail deep in the Niagara VM compile with a cryptic error. Writing Particles.Position with a plain Vector type is now auto-corrected to the proper Position type (with a warning telling you it happened), and using the integer modulo operator in custom HLSL warns up front, since the Niagara VM does not allow it (use fmod instead). Well-known particle and engine attributes are type-checked against the engine list of known attributes.
- Added: Adding an emitter or a module twice no longer stacks duplicates. add_niagara_emitter and add_niagara_module now detect an existing emitter with the same name, or the same module script already in that stage, and report it instead of adding it again. A force_add option keeps the old behavior for when you really want two.
- Added: The Niagara preview viewport refreshes on compile. If the asset is open in the editor, compiling through the tools resets the simulation so you see the new behavior immediately, no need to close and reopen the asset.
- Fixed: set_niagara_module_input no longer lies about success. It used to write module values to a store that the very next recompile regenerated from the graph, so the call returned success but the value silently reverted to the default. Values now go through the stack override, the same place the editor UI writes, so they survive recompiles and read back correctly.
- Fixed: pin_defaults on set_niagara_dynamic_input actually sets the values now. It used to write to node pins that do not exist on modern dynamic inputs, leaving every nested input at zero. The defaults are now applied through the stack after the dynamic input is wired in, and the response reports how many were applied.
- Fixed: Module input listing works for custom script modules. get_niagara_modules used to show only the input map for modules built from your own scripts; it now enumerates the real module inputs with their names and types, the same list the stack UI shows.
- Fixed: Fixed an editor crash when spawning an actor with the same name as one deleted moments before. Unreal asserts fatally on the name collision until the deleted actor is garbage collected; spawn_actor now asks for the name instead of requiring it, letting the engine pick a free one, and sets the label you asked for on top.

**v1.2.26**
- Fixed: Fixed a crash on Unreal Engine 5.7 when reading per-object property data. The objectproperties query could hard close the editor on 5.7, because the GameplayInsights provider there does not support the per-provider read lock that 5.8 uses. It now reads under the session lock on 5.7 and works the same as on 5.8. Only 5.7 was affected, and only when object property tracing was in use.

**v1.2.25** Full performance profiling arrives. Record an Unreal Insights trace from the running editor and analyze it in place: frame timing, CPU hot paths, GPU cost per pass, memory, and more, plus a live frame-rate sampler that needs no trace.
- Added: Trace recording and analysis, built in. Pick what to capture with channels and named presets, record a trace from the running editor, then run analysis queries for frame timing, CPU self time, GPU cost, memory, loading, and tasks, all without leaving your tools.
- Added: GPU per-pass breakdown. The self (exclusive) time of every named GPU pass, the same ones stat GPU shows (the base pass, Lumen, shadow depths including virtual shadow maps, ray tracing, post processing), read straight from the trace so the names follow your engine version and include your own passes.
- Added: A live multi-frame stats sampler. Frame rate and game, render, RHI, and GPU thread milliseconds averaged over many frames with a 1% low, no trace and no stat unit needed, so a single odd frame cannot mislead you.
- Added: Per-object property tracing. Register an actor, record its property values every frame, then read the history back by actor name or by id.
- Added: Channel discovery and live control, bookmarks, snapshots, and screenshots into the trace timeline, and Play In Editor start and stop so you can profile real gameplay instead of an idle editor.

**v1.2.24** The toolbar now tells you when a new version is out. The CodeFizz button turns amber when a newer plugin or CLI is available, and the panel shows what you have versus the latest, with the commands to update.
- Added: The CodeFizz toolbar button warns you when an update is waiting. When your license is active but a newer plugin or CLI has been published, the status icon turns amber instead of green and the tooltip says an update is available. A license problem still shows red, and everything current still shows green.
- Added: An Updates section in the panel that lists your installed plugin and CLI versions next to the latest published ones, marks anything out of date, and shows the exact commands to update (cfa update-all for the plugin, the npm command for the CLI), with a link to the changelog. It checks a few seconds after the editor starts, again every hour, and whenever you open the panel, so it stays current on its own without slowing startup.

**v1.2.23** Building onto an existing blueprint or PCG graph through the bridge now adds the new nodes below what is already there, and the nodes you placed yourself never move. The graph grows down the page as you add to it, instead of getting wider and wider or rearranging on you.
- Changed: When you build onto a PCG or blueprint graph, the new nodes are now placed below the existing content instead of off to the right. The graph grows downward as you keep adding to it (rather than stretching endlessly wide), and each new batch stacks under the previous one with a sensible gap, left aligned with the rest of the graph.
- Fixed: Building a PCG graph no longer rearranges the whole graph. It used to lay out every node on each build, which moved nodes you had positioned by hand. Now it only places the nodes it just added and leaves everything else exactly where it was.

**v1.2.22** PCG graph auto-layout, plus the open graph now updates live and in place on Unreal 5.6, 5.7 and 5.8. Build or lay out a PCG graph through the bridge and the nodes rearrange in front of you, with reroutes threaded onto the long wires, and no closing and reopening of the asset editor.
- Added: Auto-layout for PCG graphs. It sorts the nodes into clean left to right columns the way the engine does its own layout, keeps straight one to one chains straight, sizes each column from the real node widths when the editor is open, and drops reroute nodes onto the wires that skip a column so the graph stays readable.
- Added: Live, in place updates for an open PCG graph on every supported engine. After the bridge changes the model (adding a node, wiring a pin, laying out, inserting reroutes) the open graph rebuilds its view from the model right away, so you watch the change happen instead of finding out about it later.
- Fixed: A PCG graph no longer looks stale or empty after an edit on 5.6 and 5.7. Those versions had no built in way to refresh an open PCG editor from an outside change (only 5.8 did), so edits seemed to do nothing until you reopened the asset. The plugin now rebuilds the open editor view itself using only public editor graph calls, and it only ever touches the throwaway view copy, so the saved asset is never changed and your comments are kept.

**v1.2.20** A round of fixes from real usage: user widgets resolve by their plain name, a material instance gives a clear message instead of a not found error, color fields take a plain color value, graph nodes carry one stable id everywhere, and a node can be described without a blueprint.
- Changed: The graph analysis lists a stable node id for every node and for both ends of every connection, the same id the export and the pin links already use, so a node has one identity across all the commands instead of three different ones.
- Changed: A node can be described by its class and function without passing a blueprint to host it. A throwaway context is created for the lookup, and a blueprint is only required when you describe a node by its search id.
- Fixed: Adding a user-made widget (a Widget Blueprint) by its short name works now. Native widgets like Text Block always resolved by their plain name, but a name like WBP_MaterialButton failed unless you passed the full generated class path. It now resolves the plain name to the right class whether the widget is loaded or not, and still accepts the full path and the asset path.
- Fixed: Asking for material info on a Material Instance no longer comes back as Material not found. It now says the asset is a Material Instance and points you at the material instance parameters command, so a valid instance is never mistaken for a missing asset.
- Fixed: A color field that stores a styling rule, like a Text Block color, accepts a plain {R,G,B,A} object or an [r,g,b,a] array now, the same simple form every other color takes. The longer specified-color form still works, and an invalid field is still reported as an error instead of being silently accepted.

**v1.2.19** The editor can be closed from the agent the same way you close it by hand, with a choice to save first or discard.
- Added: You can now close the editor the same way File > Exit does, instead of killing the process. It either saves every unsaved map and asset first or discards the unsaved changes, whichever you ask for, and then runs the engine's normal shutdown so nothing is left half-written. The save and confirm popups are skipped, and only the editor you are connected to closes, so any other editors you have open are left alone.

**v1.2.18** The agent chat box wraps long lines instead of running them off the edge.
- Fixed: A long line typed or pasted into the chat box now wraps onto as many lines as it needs and re-wraps as you resize the panel, instead of stretching into one endless line behind a horizontal scrollbar. Even an unbroken run with no spaces, like a long asset path or URL, breaks to fit the width.

**v1.2.17** A large materials expansion lands, with a complete material export, layered materials, parameter collections, function instances, fuller material instances, and a real material graph auto-layout, alongside a deeper semantic Blueprint export, MVVM in the widget export, and a pass of graph edit validation that refuses the edits the editor itself would not allow.
- Added: The editor can export a material as one complete document. A single export carries every parameter (scalar, vector, texture, static switch, runtime virtual texture, sparse volume texture, and font) with its group, sort order, description, and slider range, the layer stack, the textures and material functions each node references, which node ultimately drives each material output, and a full settings block built by reflection that lists every editable property the Details panel shows, so it never goes stale. A material instance lists only the parameters and base settings it actually overrode, with an option to include everything inherited from its parent.
- Added: Layered materials. A base material or a material instance can have its whole layer stack set and read back, built from a background layer and the blend functions between the layers. A layer or blend path that fails to load comes back as a warning instead of silently leaving an empty slot.
- Added: Material Parameter Collections. Create a collection, add or update its scalar and vector entries, read them back, and remove one. A material instance also reports the group, sort order, and slider range next to each of its parameters now.
- Added: Material function instances. Make an instance of a material function, override its scalar, vector, and static switch parameters, and read the parent, base, and overrides back. Material functions can also be created as layer or blend functions for use in a layer stack.
- Added: Fuller material instances. Component mask, runtime virtual texture, and sparse volume texture parameters can be set, an instance can be reparented, and a single overridden parameter can be reverted to the value it inherits from its parent.
- Added: A real auto-layout for material and material function graphs. Nodes are placed by data flow with the ones feeding the output on the right, and long or crossing wires are routed through reroute knots, the same way Blueprint graphs are arranged.
- Added: The editor can export a Blueprint as a semantic document an AI can read like source. Every function and event comes out as a first-class entity with a clean signature, the local variables it declares and where each is read and written, the member variables it touches, the functions and macros it calls, and its event dispatcher work, and each dispatcher is listed with every place it is broadcast, bound, or cleared across all the graphs. Event bodies are followed along their execution flow, so two events linked by a dispatcher bind are never merged into one.
- Added: Widget Blueprint export now includes the MVVM layer: the view models, the bindings with both ends resolved to a view model, widget, or self along with the conversion functions they use, the older designer bindings, and a short note on each widget for which bindings drive it.
- Added: New authoring for event graphs and local variables. A Blueprint can have a secondary event graph created, renamed, or deleted, nodes can be built into a named graph instead of only the default one, and a function can be given real function-local variables that get and set nodes then use.
- Changed: Material edits are addressed by a stable node identity now, so an edit lands on the right node even after other nodes are added, deleted, or reordered, and every place that lists nodes hands that identity back.
- Changed: Connecting material nodes is more forgiving. A node with a single input, like a function output or a One Minus, can be wired by its output name instead of the connection silently failing, so a function whose output was left unconnected now connects.
- Changed: The MVVM binding commands refuse a binding the engine would reject before creating it, like a two-way binding that needs a forward-only conversion, and report the binding that actually persisted rather than leaving one that quietly fails to compile.
- Changed: Editing a material refreshes an open Material Editor consistently and marks the asset dirty whether the editor is open or closed.
- Fixed: Fixed an editor crash while exporting a material that uses hidden output pins, such as a post process, UI, light function, decal, or volume material, or a Substrate material, where reading a hidden pin came back null.
- Fixed: The Blueprint export no longer reports phantom events. The editor's greyed-out, never-called event suggestions were being written out as real events, which produced duplicate handlers, and an event dispatcher was being listed both as a variable and as a dispatcher. A dispatcher appears once now, signature types read the same as everywhere else, and each graph is tagged so a function and an event graph with the same name are never confused.
- Fixed: The graph commands now refuse edits the editor itself does not allow, instead of producing a broken Blueprint. A custom event, an input event, a timeline, or a latent node like Delay can no longer be dropped into a function or macro graph, a new variable, function, event, or dispatcher cannot take a name already used by another member or inherited from the parent class, retyping a variable to a type that does not exist is reported as an error, and the function entry and result nodes can no longer be deleted out from under a graph.

**v1.2.16** Material edits can be committed to the asset the way the editor's Apply button does, so changes made with the Material Editor open no longer sit on the preview copy.
- Added: The editor can apply a material the way the Apply button does. Edits made through the bridge land on the Material Editor's transient preview copy, so with the editor open the asset stayed stale and the Apply button stayed lit. It now marks the material dirty and runs the editor's own Apply command, which copies the preview back onto the asset, recompiles the shaders, and switches the Apply button off, the same as pressing it by hand. With the editor closed, where there is no preview, it recompiles the asset directly.
- Changed: Because it goes through the editor's real Apply command rather than reaching into editor-internal code, it behaves the same on UE 5.6, 5.7, and 5.8.

**v1.2.15** A full Widget Blueprint authoring toolset lands, covering the widget tree, properties and slots, navigation, real animations, and MVVM, alongside a new Blueprint graph auto-layout engine and a run of Blueprint authoring reliability fixes.
- Added: A whole Widget Blueprint authoring surface. The editor can build and edit a widget tree (add, remove, move, rename, duplicate, wrap, and replace widgets), read and write widget and slot properties through the same pipeline the Details panel uses so canvas anchors and offsets resync, set per-direction navigation rules, wire the designer's property bindings, reparent a Widget Blueprint, and address and fill its named slots the way the editor sees them.
- Added: Real widget animations. Create, list, and remove animations, bind and unbind the widgets they drive, and build actual MovieScene tracks and keyframes for opacity, render transform (translate, scale, shear, and angle), and color, so an animation made through the bridge actually plays instead of coming out empty.
- Added: MVVM view models and bindings. Add, list, rename, and remove a view model, and create bindings that pick the right conversion on their own when the source and destination types differ, like wrapping an int or a string so it can drive a Text field.
- Added: A new clean-room Blueprint graph auto-layout engine. Graphs come out with straight, pin-aligned execution lines, data nodes gathered into tidy clusters below the row they feed, and long or crossing wires routed through stacked reroute knots, with node sizes measured from the real widgets so the spacing is exact.
- Added: New graph edit operations: break a single link or every link on a pin, and splice an already-placed node into a running execution chain, so you can drop logic into an existing BeginPlay without rebuilding the graph. A connection can also target an existing node by its GUID, not just a node created in the same call.
- Added: A standalone MakeArray, MakeSet, or MakeMap can be given its element type directly, so a container with nothing wired to it still compiles instead of staying an undetermined wildcard. Maps take both a key type and a value type.
- Changed: The whole Blueprint graph command surface moved onto the editor's reflection layer, so every graph command exposes its real schema and is checked automatically, the same migration the rest of the tool already went through.
- Changed: Building a graph now arranges only the nodes it just added, dropped clear of anything already there, so appending to a graph you laid out by hand never moves your existing nodes. A separate pass re-arranges the whole graph on demand and is safe to run again.
- Changed: add_pin and remove_pin work for Sets and Maps now, not just Arrays, through the engine's own add-pin interface, so a multi-entry set or map can be built up one pin at a time.
- Changed: Standard macros like ForEachLoop, ForEachLoopWithBreak, WhileLoop, Gate, and DoOnce are searchable on a fresh editor now, without first opening a Blueprint that already uses them.
- Fixed: Fixed an editor crash when two custom events were built with the same name, which left the Blueprint invalid and brought down the node menu. A same-named event is reused now, or given a unique name the way the editor does.
- Fixed: Rebuilding a graph can no longer lose it. The clear step is held back until the new nodes are known good, so a failed build keeps what was there instead of wiping it.
- Fixed: The widget toolset builds on UE 5.6, 5.7, and 5.8. A version check that misfired on 5.7 patch releases had been pulling 5.8-only code into 5.7, and the MVVM binding path was using a call that only exists on 5.8.
- Fixed: Saving a Blueprint edited through the bridge no longer triggers the "Blueprint requires updating, please resave" prompt the next time you open it. A dirty Blueprint is compiled before it is saved, so it lands on disk already up to date.
- Fixed: Fixed a counter loop that never advanced because a math node reset its typed-in value the moment it was wired, so a spawn loop on BeginPlay could run forever and hang the editor on Play. Pin values are re-applied after wiring now.
- Fixed: Layout no longer pulls a pure node off the execution spine, looping and multi-chain graphs no longer fling nodes far to the right, and wiring into an existing node no longer trips an internal check.
- Fixed: Finding assets by name alone works now, across every mounted content root including plugin and engine content, instead of coming back empty when no class or path was given.

**v1.2.14** PCG editing through the bridge now behaves exactly like editing in the Details panel, with the graph and compute side deepened, plus a free trial in the editor.
- Added: A free trial is recognised and enforced in the editor. A trial license runs the plugin fully for three days, and when it lapses the license panel says so and points you to subscribe, told apart from a cancelled paid key, which keeps working on its offline grace.
- Added: A Static Mesh Spawner's weighted mesh list can be set in one go, which ensures the weighted selector, replaces the entries, and populates each one's display name, and a Custom HLSL node's kernel type can be set directly.
- Changed: Every PCG edit made through the bridge now runs the editor's real change pipeline, so it behaves exactly like a value typed into the Details panel. It refreshes the settings, recaches the node's cached output, and runs the per-node refresh the editor runs, like rebuilding a weighted mesh selector's display names or a Custom HLSL node's pins.
- Changed: Graph-level property changes, like the Hierarchical Generation grid settings, now fire the graph's real change notification, so grid linkage and compilation rebuild and any open PCG editor refreshes, instead of the value being written silently underneath the editor.
- Fixed: Fixed a correctness bug where a property written straight through reflection left the node's cached output marked valid but stale, so PCG kept reusing the old result. The cache is recached on every edit now.
- Fixed: A weighted mesh entry no longer shows None for its name after it is set, because the editor's display name refresh now runs as part of the edit.

**v1.2.13** A reflection exporter that turns any Blueprint, object, asset, or placed actor into a document an AI can read like source, plus a run of Blueprint authoring reliability fixes found by building a whole feature through the tool.
- Added: The editor can now export a Blueprint as a complete, reflection-grounded document, so an AI can read it the way it reads C++ source. It captures the class origin and compile status, every variable with its current value, all the graphs with each node's pins, connections, enabled state, and per-node compiler errors, the component hierarchy (native, the Blueprint's own, and inherited), the widget tree for Widget Blueprints with slots and animations, and the implemented interfaces and timelines.
- Added: The same export reaches past Blueprints. Any object, asset, or struct can be written out through reflection, materials come out as their full expression graph with parameters and comments, PCG graphs export every node with its enabled and debug state and resolved connections, and Animation Blueprints export their state machines, states, transitions, and the animation assets they play.
- Added: A placed actor in the level can be exported with its real live component tree, including components added to that one actor in the Details panel that never exist on the Blueprint itself.
- Added: Every export also writes a readable text version next to the data, rendered as an execution-flow tree with markers for disabled and errored nodes, so you can skim a graph without reading the raw export. Large graphs can be paged through a whole node at a time, so nothing is ever silently cut off.
- Added: A Call node built into a graph now becomes the exact specialized node the editor's palette would place, so a wildcard node like Array Length works out its type the moment you connect something to it instead of failing to compile. There is also a way to list a node's pins without placing it, by spawning it into a throwaway graph and reading the pins back, so pin names no longer have to be guessed.
- Added: Component editing now works on a placed actor's own components, not just the Blueprint class, going through the same editor subsystem the Components panel uses, so a component added this way registers, attaches, and persists with the actor like a manual add. Deleting a component, and deleting a Blueprint variable along with the nodes that referenced it, are both supported now.
- Changed: Adding, reparenting, or re-rooting a component now runs the compiler and reports the real result, the way every other structural edit already did, so a change that leaves the Blueprint in an error state is reported as a failure instead of a success.
- Fixed: Native and inherited components, the ones declared in C++ or a parent Blueprint, are now found by the name shown in the Components panel rather than their internal object name, so you can attach under one of them, like putting a mesh under a Character's inherited Mesh. Trying to reparent or re-root one gives a clear message that its attachment is fixed in code, told apart from a name that simply does not exist.
- Fixed: PCG export was dropping data. A static mesh spawner's mesh list and its bound data assets came back empty because instanced sub-objects were written as a bare path and soft references to assets that were not loaded got lost. Both are captured now, and a component parented to a native one that used to be mislabelled as a root with no parent now reports its real native parent.

**v1.2.12** Editor-side reliability across Blueprint graph building and material error reporting, plus two editor crash fixes.
- Added: Building a Blueprint graph now runs the engine compiler and reports the real outcome: whether it compiled, the error and warning counts, the messages, and the compile status. A graph that builds but fails to compile is reported as a failure instead of a success.
- Added: Graphs are arranged automatically after they are built, with a deterministic left-to-right layered layout, so nodes no longer land in a pile at the origin. Existing graphs can be tidied on demand as well.
- Added: Materials can be created with a specific domain, such as the UI domain used for widget backgrounds, and UserWidget child classes are now constructed properly through the widget tree.
- Changed: Node edits in the editor bridge are keyed on the stable node GUID through a single resolver, so an edit lands on the right node even after the graph is rebuilt, and node spawning resolves to the exact editor node, the real Set Text for example, rather than an empty placeholder.
- Changed: Blueprint asset paths resolve the way the editor resolves them, so a plain path without the _C suffix works as a class or object reference everywhere, including soft references and inside arrays.
- Fixed: Reading a material's errors now gathers the real shader compiler errors the Material Editor's Stats panel shows, including SM6, instead of reporting none when the material actually failed to compile. It compiles the material for each shader platform, waits for it to finish, and reads the errors from each, the same way the editor does.
- Fixed: Fixed two editor crashes: one while gathering a material's errors, where the temporary compile resources are now released on the render thread so they are never freed while still in use, and one when deleting a Blueprint function that is open in its own tab, where the open document is now closed first the way the Blueprint editor does it.
- Fixed: Function inputs are created with the correct pin type. Types like double, int64, and structs were becoming object reference pins; they now use the same type resolver the variable system uses, arrays included.
- Fixed: Rebuilding a graph with clear_graph clears leftover macro instances, like a stack of old ForLoop nodes, using the editor's own delete rule, while genuine function and macro boundary nodes are preserved and the existing entry node is reused instead of a stray event being added.

**v1.2.11** A second agent backend, mid-chat switching, and your chats now live outside the project folder.
- Added: Codex is now available as a second agent backend next to Claude Code. Pick whichever one you want from a dropdown in the chat panel.
- Added: You can switch agents in the middle of a conversation. The transcript stays put; the new agent just starts with a fresh context, since it cannot read the other one's memory.
- Added: A reasoning effort dropdown for the agents that support it.
- Added: The system prompt is now editable from Settings, with a Reset to Default button if you want to go back.
- Added: Drag assets or folders from the Content Browser straight onto the chat box to reference them instead of typing the path. They show up as clickable links the agent can open.
- Changed: Chats and your custom system prompt now live in the CodeFizz app-data folder, kept per project, instead of the project's Saved folder. Clearing Saved no longer wipes your history, and anything from older versions is migrated over automatically on first launch.
- Fixed: Inline formatting like bold wrapped around a code span no longer leaks raw style tags into the message.

**v1.2.10** Rich chat rendering with real code blocks, clickable assets, and image paste.
- Added: Syntax-highlighted code blocks with a language label and a Copy button. C++, Python, JavaScript, and JSON get proper tokenizing.
- Added: Fuller markdown in replies: inline code, bold and italic, ordered and nested lists, blockquotes, rules, and clickable links.
- Added: Tool chips show the command being run with a link that opens or focuses the asset it touched. Plugin mounts like /Jiggify/ resolve correctly, and asset paths written in plain text get linked too.
- Added: Paste an image with Ctrl+V and it attaches as a chip above the composer, then gets handed to the agent when you send (Windows for now).
- Fixed: The chat no longer flickers or jumps while the agent is typing. Only the message that is actually changing re-renders, and auto-scroll only follows along when you are already at the bottom.

**v1.2.9**
- Fixed: Removed the deprecated StructUtils dependency that printed a "deprecated in 5.5" warning on every build and project-file generation. The types it used to provide now come straight from CoreUObject, checked on 5.6, 5.7, and 5.8.

**v1.2.8**
- Fixed: Fixed a link failure when the plugin was dropped into a C++ project. Code projects rebuild plugins from source, and the binary drop ships without the .cpp files, so the module came up empty. It now links the shipped DLL instead of trying to recompile.

**v1.2.7** The chat panel grew up: document-style replies, a modern rounded look, and settings inside the tab.
- Added: Agent replies render as a real document, with headings, lists, fenced code, and inline formatting, instead of raw markup.
- Added: A full Settings view (License and Advanced) now lives inside the chat tab, so it stops opening a second window.
- Changed: Reworked the whole panel in pure Slate to feel like a modern chat app: rounded message bubbles, a rounded input pill, colors that follow the editor's Dark or Light theme, and a clean composer row with model and permission dropdowns.

**v1.2.6** The in-editor CodeFizz Editor Agent Chat panel landed.
- Added: A native chat panel inside the editor that drives your installed AI coding CLI (Claude Code) through your own subscription login. No API keys to handle, and the agent edits your project through the same cfa commands, so nothing about the tool layer changes.
- Added: Chat sessions are saved as transcripts you can browse, reload, resume, and delete.

**v1.2.5**
- Fixed: An engine-installed plugin now enables itself by default. Packaging was stripping the enabled flag, so an engine install (unlike a project install) came up disabled and had to be turned on by hand in every project.

**v1.2.4** Locked down the editor bridge.
- Changed: The editor bridge now requires a per-connection session token on every command, so another local process can no longer connect to the loopback port and run code once you are licensed.
- Fixed: Fixed a crash on commands that arrived with missing parameters, and moved the bridge handshake to a single atomic file.

**v1.2.3** Clear license messaging and self-serve seats.
- Added: Self-serve seat management from the panel: release this machine's seat, or deactivate all devices with the option to keep this one active.
- Changed: The license panel now shows clear, friendly messages for every state (seat limit, revoked, not found, inactive, deactivated) and points you to the right next step instead of a raw reason code.

**v1.2.1**
- Fixed: The PCG inspection commands build on UE 5.7 and 5.8 now, and the plugin declares its own dependencies so packaging resolves them cleanly in isolation.

**v1.0** The first release.
- Added: A TCP bridge plugin that exposes the Unreal editor to MCP, with native data table and material commands plus asset, blueprint, and level operations.

Before this: The list above starts where I began packaging and tracking the plugin properly. There was a long run of work before that which never got version numbers. It began as a personal tool I kept rebuilding while making my own games, so most of the core bridge, the command handlers, and the early editor integration were written and reworked many times over before any of it shipped as a release.

### CLI (codefizz-editor-agent)

**v2.7.48** The material commands get the matching CLI polish: full results from a one call function build, a safer boolean flag rule, stable node ids for surgical edits, and a rewritten material guide in the bundled skill.
- Added: Every material node command accepts a stable node id (node_guid) as well as an index, so an edit keeps pointing at the right node even after you add or remove others.
- Changed: build_material_function_graph returns the real node and connection counts and the error list when the editor is closed, instead of a fire and forget result, so you know immediately what built and what failed.
- Changed: The bundled material guide is rewritten around the full workflow: build in one call, read the errors, verify it compiles, repair one node at a time, then apply. It covers the safety guarantees, pin matching, function outputs, and the export shape. Update it with cfa skill install.
- Fixed: A boolean flag written with a space, like --clear-existing false, is now rejected with a clear message instead of being quietly read as true. Use --clear-existing=false. This closes a trap where the space form could silently wipe a graph.

**v2.7.47** The profiling flags for the thirteen new analysis queries, and a rewritten profiling guide in the bundled skill so an agent knows the full workflow, from startup traces for memory callstacks to multiplayer bandwidth setup.
- Added: Flags for the new analysis queries: allocation rules and time markers for alloc_query, direction and packet windows for the network queries, views for the animation query, and an explicit opt in flag for the 5.8 render trace analyzer.
- Changed: The bundled skill's profiling guide now covers the whole surface: the startup trace workflow for memory and callstack data, the multiplayer setup for network profiling (including the verbosity command that must run before play starts), the trigger for object snapshots, and a catalog of every query with the channel it needs. Update it with cfa skill install.
- Changed: Profiling command help states the engine support directly: everything needs Unreal 5.7 or newer, and the few 5.8 only queries say so.

**v2.7.46**
- Added: New curve commands matching plugin 1.2.41: create_curve, get_curve, set_curve_keys, delete_curve_keys, and import_curve for curve assets; create_curve_table, get_curve_table, set_curve_table_row, delete_curve_table_row, rename_curve_table_row, and import_curve_table for curve tables; and create_curve_atlas and set_curve_atlas for curve atlases.
- Changed: The bundled skill gained a guide for curves, curve tables, and curve atlases, so agents know the full workflow after cfa skill install.

**v2.7.45**
- Added: New blueprint commands matching plugin 1.2.40: create_blueprint_interface, implement_blueprint_interface, remove_blueprint_interface, list_blueprint_interfaces, create_blueprint_function_library, set_function_properties, and reparent_blueprint. create_blueprint_function now also accepts pure, const, access, category, tooltip, and metadata at creation time.
- Changed: The bundled skill gained a guide for Blueprint Interfaces, Function Libraries, and function properties, so agents know the full workflow after cfa skill install.
- Fixed: The layout_pcg_graph command was missing its reroutes option in the CLI even though the editor supported it. It is exposed now.

**v2.7.44**
- Changed: Maintenance release published alongside plugin 1.2.39. No functional CLI changes, the version moves in step so cfa update-all and self-update stay current with the latest plugin.

**v2.7.43** Sign in with your CodeFizz website account from the terminal. cfa login opens the browser, you approve this machine, and the editor plugin picks up the same activation. License keys still work as a legacy option.
- Added: cfa login with no flags opens your browser so you can sign in with the same CodeFizz account you use on the website (Google, GitHub, Discord, or email). After you approve the device code, this machine is activated and the editor plugin reads the same license automatically. There is nothing to paste into Unreal.
- Added: Legacy key login still works: cfa login --key CFA-.... Existing installs that already use a key keep working, and an upgrade does not force you to re-login if this machine is already activated.
- Changed: cfa self-update, check-updates, doctor, and health_check now tell you clearly when this machine is not signed in, and point you at cfa login. Self-update does not clear your license; if you were already signed in, you stay signed in after the binary updates.
- Changed: Unlicensed error messages for install-plugin, update-all, and related commands spell out the next step (run cfa login, then retry), so a missing login is not a dead end.

**v2.7.42**
- Changed: The bundled skill now documents the two material slot commands, get_material_slots and set_materials_batch, so an agent knows how to read a mesh's element slots and assign materials by slot on placed actors and Blueprint component defaults, on one target or many, without guessing.

**v2.7.41** Two new commands for working with materials from the terminal, one to read the material slots of any mesh and one to assign materials by slot on actors and Blueprints.
- Added: get_material_slots lists the element slots of any actor, Blueprint, or static mesh, with the slot name, current material, and whether each slot is overridden.
- Added: set_materials_batch assigns materials by slot or slot name, on one target or many at once, on placed actors and on Blueprint component defaults, and can clear a slot back to the mesh default. See the plugin notes for the full behavior.

**v2.7.40** The Sequencer commands are available as cfa subcommands, and the bundled skill gained a complete Sequencer guide so an agent can author and render a cinematic correctly, from the first command to the final video, without guessing.
- Added: The whole Sequencer command family is exposed as cfa subcommands, discoverable with cfa commands sequencer and cfa describe, so you can build and render a Level Sequence entirely from the terminal.
- Added: The bundled skill now carries a full Sequencer reference: the complete command inventory grouped by job, the exact parameter names that trip people up, the spawnable first approach for sequences that stay consistent between editing and rendering, how to animate a component property like light color or intensity, the render to video pipeline, and the traps found in real use so a render frames the subject the first time.

**v2.7.39** The new project settings commands are available as cfa subcommands, and the bundled skill gained a project settings reference so an agent can find, read, and change any project setting without guessing.
- Added: search_project_settings, get_project_settings, and set_project_settings are exposed as cfa subcommands with help and examples, so you can search for a settings section, read its properties, and change them from the terminal, and it writes to the right Default config file for you.
- Added: The bundled skill has a new project settings reference. It covers the discover then read then edit flow, how settings map to a config object and where they persist (including console variable backed settings that save under their variable name), the validation errors that tell you what a property wants, dotted and indexed edits for arrays and nested structs, the collision recipes for channels and presets and per preset responses, and the traps to know, such as a section that has not registered yet still being reachable by class name. New installs and anyone who updates get it with the CLI.

**v2.7.38** The new level lifecycle and lighting commands are available as cfa subcommands, and the bundled skill gained a lighting reference so an agent sets up outdoor lighting the right way without guessing.
- Added: The level lifecycle and lighting commands are exposed as cfa subcommands with help and examples: list_level_templates, create_level, open_level, save_level, save_level_as, and setup_default_scene with its lighting presets (clear, noon, sunset, overcast, snowy, night).
- Added: The bundled skill has a new lighting reference. It covers the six actor sky system driven by the sun, the one call setup_default_scene preset workflow, and the rules that decide whether lighting looks right: edit the light component not the actor, use a physically real sun intensity with a fixed manual exposure so the result does not depend on the project settings, keep fog subtle, and drive cloud coverage from the cloud material instance using the existing material commands. The level design reference now also documents creating, opening, and saving a level. New installs and anyone who updates get it with the CLI.

**v2.7.37** The new level design commands are available as cfa subcommands, and the bundled skill gained a level design reference so an agent knows the workflow without guessing.
- Added: The level design commands are exposed as cfa subcommands with help and examples: get_mesh_info, spawn_actors_batch and delete_actors_batch, get_scene_map (the clustered summary, with drill and label filter), capture_top_down, the focus_viewport angle options, and the outliner commands (move_actors_to_folder, create_folder, delete_folder, rename_folder, list_folders, group_actors, ungroup_actors, attach_actors, detach_actors).
- Added: The bundled skill has a new level design reference. It covers building a level from data, understanding it with the clustered scene map, capturing a top down floor plan, and organizing the outliner with folders, groups, and attachment, along with the gotchas that matter (mesh pivot, label versus class filter, clustering distance). New installs and anyone who updates get it with the CLI.

**v2.7.36** cfa self-update is now reliable the instant a release ships, updates from the right source per install type, and no longer downloads anything just to check whether you are current.
- Fixed: cfa self-update is now fully aware of how cfa was installed and updates from that source directly. A direct install (the codefizz.dev one line installer) downloads the newest build straight from storage and reads the version from the binary itself, so it is never blocked by a cached version number. An npm install updates through npm (npm install -g codefizz-editor-agent@latest), with npm as the source of truth. Neither path depends on a shared version endpoint, so a slow or stale lookup can never delay or misdirect an update.
- Fixed: cfa self-update no longer downloads the whole binary just to see whether you are already current. It reads a tiny version marker first and only downloads when there is actually a newer version, so an up-to-date check is instant. The binary download also retries a dropped connection, so a brief network blip no longer fails an update.
- Fixed: If another cfa is running when you self-update (usually your editor MCP server holding the file), the update retries and, if still blocked, tells you to close the tool and run it again instead of showing a raw access denied error.

**v2.7.33** The cfa CLI exposes the new export_statetree command, and the bundled StateTree guidance points to it as the fastest way to read a whole tree.
- Added: export_statetree exports a StateTree to a self-contained JSON file and returns the path plus a compact summary. Add --inline to also print the whole document. It surfaces the plugin new StateTree exporter from the terminal, with full help describing what the JSON captures.
- Changed: The bundled StateTree guidance now points to export_statetree as the fastest way to read a whole tree at once (one self-contained JSON file), so an assistant reaches for it instead of running a stack of separate queries.

**v2.7.31** The cfa CLI learns the new StateTree and component commands, and the bundled skill gains a full StateTree reference, so an assistant can build a working AI from the terminal without guessing.
- Added: New StateTree reference in the bundled skill. It lays out the schemas and where each one goes (a plain StateTree component on any actor, the AI component that has to sit on an AI controller, the Mass one for entities), the order to build a tree, how to author your own Blueprint task and condition nodes, how bindings and parameters work, and the traps that waste time.
- Added: Commands for the new plugin features come with full help: set_blueprint_component_property, set_statetree_parameter, override_blueprint_function, and the value and properties options on the parameter and component commands.

**v2.7.30**
- Fixed: cfa self-update on an npm install no longer prints a block of npm cleanup warnings. The update always worked, but npm could not remove the old copy while cfa was still running and warned about it in red, which looked like a failure. Those harmless warnings are now hidden while real errors still show.

**v2.7.29** cfa no longer needs Node or npm. A one line PowerShell installer puts the self-contained exe on your PATH, and a new cfa self-update command keeps it current from then on. The npm package keeps working exactly as before, pick whichever you prefer.
- Added: One line install with no dependencies: irm https://codefizz.dev/install.ps1 | iex downloads the standalone cfa.exe, puts it on your PATH, and verifies it runs. From classic cmd, wrap it in powershell -c "...". Nothing else to install first.
- Added: New cfa self-update command. It knows how it was installed: an npm install is updated by running npm install -g for you, a direct install downloads the new build and replaces itself in place, safely, even while cfa is running. Works even when a trial has expired, so updating is never locked out.
- Changed: The update notice and cfa check-updates now show the update command that matches how your cfa was installed, instead of always pointing at npm.
- Changed: The installer warns when a second cfa from another install method is on your PATH, and tells you how to remove the old one so there is no confusion about which copy runs.

**v2.7.28** The cfa CLI gains the export_niagara command and the bundled skill learns to use it, so reading a Niagara effect from the terminal is now one call plus a JSON file.
- Added: New export_niagara command with flags to control the output, include_values to read the live input values, include_referenced_graphs to inline the referenced assets if you want everything in one file, include_stage_graphs for the raw per stage graphs, and inline to return the JSON in the response instead of only the file path.
- Changed: The bundled skill Niagara reference now teaches export_niagara as the preferred way to read and understand an effect, when to use it, what the JSON contains, and how to read just the part you need instead of the whole file.

**v2.7.27** The Niagara command set and the bundled skill catch up with the plugin revamp: new flags for the reworked commands, and a rewritten Niagara reference that teaches the agent the full build, compile, verify workflow.
- Added: New flags on the Niagara commands: force_add on add_niagara_emitter and add_niagara_module to bypass the new duplicate detection, and finalize on build_niagara_graph to control the automatic compile and apply.
- Changed: The bundled skill Niagara reference is rewritten around how the tools now behave. It walks the agent through authoring an effect end to end: build the graph, let it finalize, set values through the fixed setters, then verify every value by reading it back instead of trusting a success response. It also covers custom HLSL rules (fmod over integer modulo, Position typing) and proper looping (Loop Behavior set to Infinite with a sane loop duration, instead of absurd hundred-thousand-second lifetimes that stretch the timeline).

**v2.7.26** health_check is now a full setup report. In one call it tells you the CLI is working, your license status, and whether an editor is connected, and it no longer looks like a failure just because no editor is open yet.
- Added: health_check now reports your license as well, whether it is active or a trial, the account email, and the expiry date. It reads this from the local license, so it works even with no editor running, and it runs without a license too, so when your license is not active it can tell you that and what to do instead of being blocked.
- Changed: health_check no longer fails when no editor is open. It reports the CLI and license as healthy and points you to the next step, open your project in Unreal the normal way then run it again, so a fresh setup reads as ready rather than broken.
- Changed: The result is split into clear parts, cli, license, and editor, with a one line summary. It stays scoped to your current project, and when your project is not the one running it lists the editors that are, so you can connect to one.

**v2.7.25** A full performance profiling command set, drive Unreal Insights recording and analysis from the terminal, plus a live frame-rate sampler that needs no trace.
- Added: The performance command set (start_trace, stop_trace, analyze_insight, live_start, live_stop, and the trace controls) that records and analyzes performance from the terminal.
- Added: Dozens of analysis queries: frame bound, per-thread breakdown, flame, hot path, GPU passes, GPU sync, counters, memory growth, GC pauses, hitch cause, CSV stats, trace compare, and critical path.
- Added: A profiling reference in the bundled skill so the agent knows how to profile end to end, from entering Play In Editor and choosing channels to reading each query.
- Changed: Command discovery now steers the agent to the CLI over MCP, so looking up a command costs no extra context.

**v2.7.23** cfa now tells you when a newer version is out, both on its own as you work and on demand with a new check-updates command.
- Added: A new cfa check-updates command. It checks the CLI and every plugin install you have against the latest published versions, then prints what is out of date and the exact command to update each one. It works even without a license, since checking for updates should never be gated.
- Added: cfa prints a short heads up when a newer version is available, the next time you run a command. It checks at most once an hour and caches the result, and stays quiet for scripts and machine output (JSON, the MCP server, anything not run in a terminal), so it never gets in the way of tooling.

**v2.7.22** New launch, engines, and project_info commands. You can open any .uproject in the exact engine it targets and the configuration you choose, and launch waits until the editor is actually ready before handing back its port.
- Added: launch opens a .uproject in the right engine and build configuration. It reads the project's engine association the way Unreal itself does (a launcher version opens the launcher engine, a source-build GUID opens that source build), picks the editor binary for the configuration you ask for (Development by default, or DebugGame, Debug, or any configuration that is actually built), and by default waits until the editor bridge is ready before returning its port and pid. The wait is event driven off the file the plugin writes the moment its bridge comes up, so it reports ready the instant it is, with no polling.
- Added: engines lists every Unreal engine installed on this machine, with its version, path, how it was found (Epic Launcher, registry, or a registered source build), and which editor configurations are actually built for it.
- Added: project_info shows what a project would launch with, without opening it: its raw engine association, the engine that resolves to, the configurations available for that engine, and whether the project is already running.

**v2.7.21**
- Added: install-plugin takes a local zip with the new --from flag, so you can install a build you just packaged without downloading the published one. It runs the same DebugGame and module setup the normal install does, which makes it easy to try a version before it ships.

**v2.7.19** A stale editor selection no longer trips up routing, and describe_node works without a blueprint for a library function.
- Changed: describe_node no longer needs --blueprint-path for a class and function lookup. A throwaway context is used for those, and a blueprint is only required when you describe a node by its node id.
- Fixed: A saved connection that points at an editor which is no longer running is ignored and cleared on its own now, so a dead selection can never quietly send a command to the wrong editor, and status marks whether the selected editor is actually running.

**v2.7.18** A new quit_editor command closes the connected editor gracefully, saving first or discarding.
- Added: quit_editor closes the editor it is routed to the way File > Exit does, never by killing the process. By default it discards unsaved changes; pass --save to write every unsaved map and asset first. Either way the save and confirm popups are skipped, it returns its result before the editor exits, and it closes only the editor it is connected to, so any others stay open.

**v2.7.16** A large set of material commands lands, covering a complete material export, layer stacks, parameter collections, function instances, and fuller material instances, plus new semantic Blueprint export and event-graph and local-variable commands, and the editing commands now refuse anything the editor itself would reject.
- Added: A big set of material commands. set_material_layers and get_material_layers build and read a material's layer stack on either a base material or an instance. create_material_parameter_collection with its set, get, and delete commands manages a Material Parameter Collection and its scalar and vector entries. create_material_function_instance with its set and get commands instances a material function and overrides its parameters, and create_material_function takes a function_type of function, layer, or blend.
- Added: set_material_instance_parameter covers component mask, runtime virtual texture, and sparse volume texture parameters now, set_material_instance_parent reparents an instance, and clear_material_instance_parameter reverts a single overridden parameter back to the parent value. get_material_instance_parameters reports each parameter's group, sort order, and slider range.
- Added: export_asset writes a complete material document: every parameter with its group, order, description, and slider range, the layer stack, the textures and material functions each node uses, which node drives each material output, and a settings block of every editable material property. A material instance exports only what it overrode, with include_inherited to get the full picture.
- Added: layout_material_graph and layout_material_function_graph arrange a material graph by data flow with the output side on the right and route long wires through reroute knots, the same layout engine the Blueprint graphs use.
- Added: New Blueprint export. export_asset on a Blueprint writes a semantic document where every function and event is a first-class entity with its signature, the local variables it declares and where they are used, the member variables and dispatcher operations it touches, and the functions it calls, and every event dispatcher is listed with each place it is broadcast, bound, or cleared.
- Added: create_event_graph, rename_event_graph, and delete_event_graph manage a Blueprint's secondary event graphs, build_blueprint_graph takes a graph_name to target a specific graph, and create_local_variable adds a real function-local variable that var_get and var_set can then use.
- Added: The widget export gained the MVVM layer: the view models, the bindings with both ends and their conversion functions, and a per-widget note of the bindings that drive it.
- Changed: Material node commands are addressed by a stable node_guid now, so an edit lands on the right node after other nodes are added, deleted, or reordered, and that guid is handed back everywhere nodes are listed.
- Changed: Connecting material nodes is tolerant of a single-input node, so a node like a function output or a One Minus can be wired by its output name instead of the connection silently failing.
- Changed: add_mvvm_binding and set_mvvm_binding reject a binding the engine would not accept before creating it, and report the binding that actually persisted instead of leaving one that fails to compile.
- Changed: A material scalar or vector value can be given as a plain JSON number array now, the natural form for a color or a vector.
- Fixed: Fixed an editor crash while exporting a material that uses hidden output pins, like a post process, UI, decal, or Substrate material.
- Fixed: The Blueprint export no longer writes phantom events from the editor's greyed-out suggestions, no longer lists an event dispatcher as both a variable and a dispatcher, and tags each graph so a function and an event graph with the same name are not confused.
- Fixed: The Blueprint editing commands refuse what the editor refuses. A custom event, input event, timeline, or latent node like Delay cannot be added to a function or macro graph, a new member cannot take a name already in use or one inherited from the parent class, retyping a variable to a type that does not exist is an error, and the function entry and result nodes cannot be deleted.

**v2.7.15** A new apply_material command commits a finished material to the asset, and the bundled skill documents it as the last step of the material workflow.
- Added: apply_material commits a material's pending edits to the asset, the same as clicking Apply in the Material Editor. With the editor open it runs the real Apply, so the preview is copied onto the asset, the shaders recompile, and the Apply button goes quiet; with the editor closed it recompiles the asset directly. It reports whether the editor was open so you can tell which path ran.
- Changed: The bundled Agent Skill's material workflow now ends on apply_material, called once when the material is finished rather than after every edit, since applying recompiles the shaders.

**v2.7.14** The plugin loads when the editor runs in DebugGame, not only Development.
- Fixed: The plugin loads in a DebugGame editor now, not just a Development one. A DebugGame editor looks for a differently named module manifest and a DebugGame build of the plugin, which the Development-only binary does not carry, so the module came up missing, the editor kept offering to rebuild it, and it rewrote the manifest back to the missing name on every launch. The editor module is the same binary in both configurations, so install-plugin and update-all now place a DebugGame-named copy of the DLL next to the Development one and point the DebugGame manifest at it. The module is then found and up to date, the editor stops asking to rebuild, and the fix holds across launches. Works on both Launcher and source engines.

**v2.7.12** The plugin loads on a source-built engine, not just an Epic Launcher one.
- Fixed: install-plugin and update-all now make the plugin load on a source-built engine. The editor only accepts a binary whose build id matches the engine's own, and a source build uses a per-build id the packaged plugin cannot carry, so it was reported as built with a different engine version. The CLI now detects a source build the same way the engine does, by the absence of InstalledBuild.txt, reads the engine's own build id, and writes it into the installed plugin so it loads without a rebuild. Launcher installs are untouched. This aligns the compatibility tag only, so it assumes a matching, unmodified release built in Development.

**v2.7.11** A full UMG and Widget Blueprint command set, a new Blueprint graph auto-layout engine, and the blueprint-graph commands moved onto the reflection layer, plus a batch of authoring fixes.
- Added: A complete Widget Blueprint command set. Build and edit a widget tree (add_widget, remove_widget, move_widget, rename_widget, duplicate_widget, wrap_widget, replace_widget, create_widget_blueprint), read and write widget and slot properties (get and set_widget_properties, get and set_slot_properties) through the editor's real edit pipeline, set navigation, wire the designer's property bindings, list widget events, and manage named slots.
- Added: Widget animation commands: create, list, and remove an animation, bind and unbind the widgets it drives, and build real MovieScene tracks and keyframes with add_animation_track and add_animation_key for opacity, render transform, and color, so the animation actually plays instead of being created empty.
- Added: MVVM commands: add, list, rename, and remove a view model, and add, list, and remove MVVM bindings, with the binding choosing the right conversion on its own when the source and destination types differ.
- Added: New blueprint graph commands. break_node_link disconnects one link or every link on a pin, and insert_node_in_exec splices an existing node into a running exec chain. build_blueprint_graph can wire a connection to an existing node by its GUID, type a standalone MakeArray, MakeSet, or MakeMap through element_type (and value_type for maps), and arrange itself with the new auto-layout engine.
- Changed: All twenty blueprint-graph commands moved onto the reflection-driven command layer, so each one exposes the schema the editor generates and the CLI specs are checked against it automatically, the same drift protection the rest of the surface already had.
- Changed: build_blueprint_graph arranges only the nodes it just added, anchored clear of existing content, so appending never moves your hand-placed nodes, and a new arrange_blueprint_graph re-lays a whole graph and is safe to run again. The layout help now says to leave auto-layout on and not pass positions.
- Changed: add_pin and remove_pin work on Sets and Maps now, not just Arrays, so a multi-entry set or map can be built one pin at a time.
- Changed: Standard macros like ForEachLoop and ForEachLoopWithBreak are searchable on a fresh editor now, without opening a Blueprint that already uses them first.
- Changed: export_blueprint, export_object, and export_actor stop dumping the whole export inline for a large asset. Anything past a small size returns the path and byte count instead, so the real result is not buried under a 150 KB graph.
- Fixed: Fixed an editor crash when two custom events were built with the same name. The duplicate is reused or uniquely named now, instead of leaving the Blueprint invalid and bringing down the node menu.
- Fixed: Rebuilding a graph with clear_graph no longer wipes it on a failed build. The clear is deferred until the new nodes are known good.
- Fixed: A math node no longer drops its typed-in value when it gets wired, which had a counter loop never advancing and a BeginPlay spawn loop running until the editor hung. Pin defaults are re-applied after wiring.
- Fixed: Looping and multi-chain graphs lay out cleanly now, instead of flinging nodes far to the right or pulling a pure node off the exec line.
- Fixed: find_assets returns matches when given only a name, across every mounted content root, instead of coming back empty.
- Fixed: The widget commands build on UE 5.6, 5.7, and 5.8, including the MVVM and UI-component paths that previously leaned on calls that exist only on 5.8.
- Fixed: Saving no longer leaves a Blueprint in a state that triggers the editor's "please resave" prompt on next open, because a dirty Blueprint is compiled before it is saved.

**v2.7.10** PCG editing reaches editor parity, with new commands for the things that used to take a whole sequence of calls, all on a new reflection-driven command layer.
- Added: build_pcg_graph builds a whole graph, many nodes and edges, in one transaction, laying them out left to right when you do not pass positions, and rolling the whole thing back if any part fails so you never end up with a half-built graph. Nodes carry a stable node_name now, so an edit lands on the right node even after another node is deleted, where the old index could quietly shift onto the wrong one.
- Added: New commands for the things that used to take a sequence of calls: set_pcg_static_mesh_spawner_meshes sets a spawner's whole weighted mesh list in one call, set_pcg_graph_property and get_pcg_graph_properties read and write graph-level properties like Hierarchical Generation, and set_pcg_custom_hlsl_kernel_type sets a Custom HLSL node's kernel type. node_name is accepted on every node-target command.
- Added: A dump_command_schema command exposes the schema the editor generates for each command, and the CLI's own command specs are checked against it automatically so the two can never drift apart. The bundled Agent Skill docs gained a PCG reference covering the new workflow.
- Changed: Every PCG property edit now behaves exactly like editing the node in the Details panel. It runs the editor's real change pipeline, so the cached output is recached and the per-node refresh runs, instead of writing the value underneath the editor and leaving stale state behind.
- Changed: read_pcg_graph is lean by default, returning labels, edge counts, and connections, with the per-pin metadata available behind include_pin_meta when you want it.
- Fixed: A weighted mesh entry no longer comes back as None after it is set, and a property written through reflection no longer leaves the node's output cache stale, which had PCG reusing old results.

**v2.7.9**
- Added: A free trial. A trial license activates the CLI for three days, and when it expires the CLI stops with a clear message to subscribe, told apart from a cancelled paid key, which keeps working on its offline grace. whoami shows when you are on a trial.

**v2.7.8** The reflection exporter lands as a set of export commands, alongside a batch of Blueprint authoring fixes found by building an entire feature through the CLI.
- Added: export_blueprint writes a Blueprint out as a complete, reflection-grounded document you can read like source: the class origin and compile status, every variable with its value, all the graphs with each node's pins, connections, enabled state, and per-node compile errors, the component hierarchy, the widget tree for Widget Blueprints, and the implemented interfaces and timelines. Scope flags (sections, graph, node, depth) narrow it to just the part you want.
- Added: export_object exports any object, asset, or struct through reflection, and export_asset picks the right exporter by type, so materials export as their expression graph, PCG graphs export every node with its enabled and debug state, and Animation Blueprints export their state machines and the animation assets they play.
- Added: export_actor exports a placed actor with its real live component tree, including components added to that one actor in the Details panel that are not on the Blueprint. Every export also writes a readable .txt next to the data, and a big graph can be paged through with page and page-size so nothing is silently truncated.
- Added: describe_node lists a node's pins without placing it, and search_nodes takes a --with-pins option, with a blueprint-path, that returns each match's pins inline, so pin names like Vector Distance V1 and V2 no longer have to be guessed. delete_blueprint_variable removes a variable and rebuilds its references, and a new function_result node kind lets build_blueprint_graph wire a function's return values in the same call.
- Changed: search_nodes matches whitespace and camelCase loosely and against the underlying function name, so "DestroyActor" finds "Destroy Actor", and it now returns a ready-to-use call spawn for promotable math and comparison operators like Add and Less. Call nodes in build_blueprint_graph spawn the exact specialized node class the editor uses, so wildcard nodes like Array Length resolve their element type the moment they are wired instead of failing to compile.
- Changed: The component commands (add, delete, reparent, set root) now take either a blueprint-path to edit the class or an --actor to edit a single placed actor's own components, through the same editor backend the Components panel uses, and they report the real compile result.
- Changed: The "no editor running" messages now name the likely case where an editor is open but still loading or waiting on a rebuild prompt, instead of implying nothing is running at all.
- Fixed: Native and inherited components are found by the name shown in the Components panel now, so you can attach under one like a Character's inherited Mesh, and trying to reparent or re-root a native component gives a clear "its attachment is fixed in code" message told apart from a missing name.
- Fixed: add_function_input and add_function_output resolve object versus class correctly: a bare class name makes an object pin, and param_kind=class makes a TSubclassOf pin. create_blueprint_variable normalizes a class or object default path so it no longer compiles to None, and find_actors_by_name matches the actor label too, not just the internal object name.
- Fixed: PCG export no longer drops a static mesh spawner's mesh list or its soft references to assets that are not loaded.

**v2.7.7** A big reliability pass on Blueprint graph building, with real compile reporting, automatic node layout, sharper material error reporting, and two editor crash fixes.
- Added: build_blueprint_graph and compile_blueprint now report the real compile result: whether it compiled, the error and warning counts, the messages, and the status. A graph that wires up but fails to compile comes back as an error instead of a false success.
- Added: Blueprint graphs arrange themselves. build_blueprint_graph lays nodes out left to right by default so they no longer pile up at the origin, and a new arrange_blueprint_graph command tidies an existing graph.
- Added: search_nodes returns a ready-to-use spawn descriptor for each match, so the builder places the exact node you meant, like a real SetText, instead of an empty stand-in.
- Added: create_material takes a --domain now, so you can make a UI material for widgets directly. add_widget can build UserWidget child classes from a plain path, mark a widget as a variable, and insert at an index, and there is a new get_blueprint_class_defaults command.
- Changed: A Blueprint asset path without the _C suffix now resolves everywhere a class or object reference is expected, including soft references and array elements. Node edits are keyed on the stable node GUID, so they hit the right node after a rebuild, and commands hand that node_guid back.
- Changed: Git Bash content-path healing now also covers paths passed inside --value, --json, and --nodes, not just positional arguments.
- Fixed: get_material_errors now reports the shader compiler errors the editor's Stats panel shows, including SM6, instead of coming back empty when the material actually failed to compile. It compiles the material for each platform and tags every error with the platforms it came from.
- Fixed: Fixed two editor crashes: reading a material's errors, where the temporary resources are now released on the render thread instead of while they are still in use, and deleting a Blueprint function that is open in a tab, where the tab is now closed first the way the editor does it.
- Fixed: add_function_input builds the correct pin type now. Types like double, int64, and structs used to come out as object reference pins; they go through the same resolver the variables use, array parameters included.
- Fixed: Rebuilding a graph with clear_graph no longer leaves dead macro nodes behind, like a stack of old ForLoops, and kind:event or function_entry reuses the existing entry node in function and macro graphs instead of dropping in a stray event that left the body disconnected.

**v2.7.6**
- Changed: Refreshed the bundled Agent Skill docs now that content paths repair themselves in any shell. The old "use PowerShell, not Git Bash" advice is gone, since it would only steer the agent away from a shell that now works fine.

**v2.7.5**
- Fixed: Content paths that start with /Game (or any mount root) now work from Git Bash. MSYS used to rewrite them into the Git install path before the CLI ever saw them, so the editor reported "asset not found" and you had to retry in PowerShell. The CLI now heals the path quietly, custom mounts included.

**v2.7.4**
- Fixed: Tolerate a UTF-8 BOM when reading .uplugin and .uproject files, and write them without one. A stray BOM was making the installed-version check read as empty, so installs and rollbacks kept reinstalling or showing the wrong label.

**v2.7.3**
- Added: cfa update-all reinstalls the plugin everywhere you have put it, every engine and every project, in one command. It goes to the latest build by default, or to a specific --version for a fleet-wide rollback or pin, with --dry-run, --prune, and --force.

**v2.7.2**
- Added: install-plugin into a project on a source-built engine now figures out the engine automatically from its GUID, the same way Unreal does, instead of failing and asking you to pass --engine.

**v2.7.1**
- Changed: Plugin installs now extract into a staging folder and swap into place atomically, so a failed extract can never corrupt an install you already had.
- Fixed: Fixed installs from zips packaged with backslash path separators, which used to leave a broken install with an empty Binaries folder and no DLL. Extraction now handles either separator.

**v2.7.0** Tighter security around the bridge and plugin downloads.
- Changed: The CLI now sends the editor bridge's session token on every request automatically, resolved per editor so cross-project routing authenticates against the right one.
- Changed: Plugin downloads are verified with an Ed25519 signature over the checksum before anything is extracted, and they fail closed if the checksum is missing. Local files are written with tighter permissions.

**v2.6.6**
- Added: cfa uninstall-plugin removes the plugin from an engine or project and tidies up the install registry. It is purely local, so it works even when you are logged out, and running it where nothing is installed just says so.

**v2.6.5**
- Changed: License messages now tell you exactly what happened and what to do next, and point you at codefizz.dev/account. There are separate, clear cases for a regenerated key, an admin revoke, a deactivated machine, a seat limit, and an inactive subscription, instead of one scary "revoked".
- Changed: cfa login now takes a seat while the background recheck does not, so a machine you deactivate from your account page is told to log in again instead of silently taking its seat back.

**v2.6.4**
- Fixed: Plugin downloads and version listing now retry transient network errors and rate limits with backoff, so a momentary 429 or 503 no longer turns into a hard failure. The startup license check stays single-shot so offline use never hangs.

**v2.6.3**
- Added: install-plugin auto-detects the engine or project by walking up from the path you give it, verifies a checksum, caches the download, and takes a --version for installing or rolling back to a specific build.
- Added: cfa plugin versions lists every available build per engine, and cfa plugin status shows where the plugin is installed and whether it is up to date.

**v2.6.0** The CLI became how you license and install the plugin.
- Added: cfa login, logout, whoami, and deactivate-all activate a machine with your license key. You enter the key once in the CLI, and it gets written to a shared store the editor plugin reads too, so you never paste it into the editor.
- Added: install-plugin downloads the right licensed build for an engine and installs it for you. The CLI finds your installed engines the same way Epic does, through the launcher manifest and the registry.
- Added: One license seat shared between the CLI and the plugin, with a signed offline fallback so it keeps working without a connection for a while.

**v2.5.6**
- Fixed: Edits made through the bridge now show up in an open Niagara editor. The preview reinitializes after each edit, and adding an emitter rebuilds the system graph so the timeline no longer stalls at the start.

**v2.5.4**
- Added: get_niagara_module_inputs ranks matches by relevance and takes max_results, so a module that exposes dozens of inputs returns just the few you asked for.
- Fixed: Fixed a use-after-free crash in set_niagara_rapid_iteration_parameter, where a recompile reallocated the parameter store out from under a pointer.
- Fixed: set_niagara_scratch_pad_hlsl is idempotent now, reconciling pins by name and type instead of piling up duplicates on repeat calls.
- Fixed: get_niagara_system_errors surfaces the real compile messages instead of a generic error, and take_screenshot forces a fresh draw so repeated captures are not byte-for-byte stale.

**v2.5.3**
- Added: Deeper Niagara authoring: full-stack validation that reports every issue the editor would show, an auto-fix that runs the editor's own Fix one issue or all until clean, creation of Niagara data and utility assets, and standalone emitter and script authoring.

**v2.5.2**
- Added: UE 5.6 support across the tool surface, alongside 5.7 and 5.8.
- Fixed: set_niagara_renderer_binding actually applies now. It advertised one parameter name but read another, so the value never reached the bridge.

**v2.5.0**
- Added: Multi-editor routing: list_editors, connect_editor, disconnect_editor, and connection_status. Commands route to a specific editor by port, current project, or connected session, and refuse rather than guess when it is ambiguous. The choice sticks per agent across separate shells.

**v2.3.0**
- Added: translucency_lighting_mode and refraction_method on set_material_properties, done in a cross-version-safe way.
- Fixed: Hardened the material commands: accept Custom HLSL whether it is top-level or nested, fix build_material_function_graph index resolution, and parse static switch and preview values from strings.

**v2.2.0**
- Added: Blueprint event dispatcher (multicast delegate) support: create one, then call, bind, assign, unbind, or clear it from the graph builder, including across blueprints.

**v2.1.0**
- Added: A bound_event graph node to wire a widget or component delegate, like a Button OnClicked, to an event the way the UMG editor does.
- Changed: UMG widget and slot properties now flow through the generic object commands, with nested paths, array ops, and batch maps, so the redundant widget-property commands were removed.
- Fixed: UserWidget events (Construct, Tick) resolve now, and create_material_instance no longer reads an object-form vector parameter as black.

**v2.0.5**
- Added: The asset_ops toolset for bulk asset maintenance: batch move and rename with reference repointing and redirector fixup, reference-checked batch delete, candidate search, and replace-references between assets. Built to avoid the editor's modal dialogs so it is safe to run headless.

**v2.0.4**
- Added: A bundled Agent Skill is embedded in the binary, and cfa skill install writes it to every AI agent it finds (Claude, Gemini, Copilot, Cursor, Windsurf, and others).

**v2.0.3**
- Added: A structs command group to author and edit Blueprint structs (UserDefinedStruct): create with members, add, set, remove, describe, and a ranked list.
- Changed: The CLI accepts the MCP tool names too (describe_command, search_commands), and it catches Git Bash rewriting a leading /Game content path, failing fast with the fix instead of a confusing editor error.

**v2.0.2**
- Added: create_data_table builds a table with its row struct headlessly, no modal picker, and a ranked list_data_table_row_structs helps you find a valid row struct.

**v2.0.0** Everything became one reflection-driven object system.
- Changed: Generalized the object commands. describe_object, get_object_property, and set_object_property now cover any UObject (data assets, Blueprint CDOs, component templates, placed actors, live components), so the overlapping data-asset and Mass Config commands were removed.

**v1.8.0**
- Added: Replicated custom-event RPCs and cross-object variable nodes, with clearer error surfacing when a node or pin does not resolve.

**v1.5.0**
- Added: Context-sensitive node search, a bulk graph builder that places and wires nodes in one call, and pin default values.

**v1.4.0** Real Blueprint authoring from the agent.
- Added: Designer-grade Blueprint authoring through a few generic, search-driven tools: any-type variables, context-sensitive node search and spawn, and typed wiring, instead of many narrow commands.

**v1.3.9**
- Changed: Removed seven redundant commands and added editor-grade archetype propagation, so changing a template reflects on its instances the way the editor does.

**v1.3.7**
- Changed: A unified reflection property system across the commands, standardized on a single blueprint_path key, so every object command reads and writes properties the same way.

**v1.3.3**
- Added: Tiered command discovery with MCP meta-tools (search and describe) and per-client install exposure, so only the core tools plus the meta-tools load by default and you turn on a toolset when you need it.

**v1.3.1**
- Changed: The cfa binary is bundled straight into the npm package, so installing no longer downloads a separate release from GitHub.

**v1.2.1** A huge release: the rebrand, an MCP server, and whole new tool suites.
- Added: The Niagara VFX tool suite: author systems, emitters, module stacks, renderers, scratch pads, and parameters, with ViewModel-based parameter linking and diagnostics.
- Added: StateTree authoring for states, transitions, evaluators, conditions, tasks, and bindings.
- Added: A comprehensive PCG tool suite: component lifecycle, partition inspection, subsystem scheduling, cache and runtime generation, and execution inspection.
- Added: Console-command tools (list, info, exists, execute) and surgical Mass Entity Config trait commands that edit one trait without disturbing the rest.
- Added: Reflection-driven control of placed actor instances from the editor.
- Changed: Rebranded to CodeFizz Editor Agent, added a built-in MCP server, and dropped the Python package so everything runs through the one cfa binary. cfa install registers it with your AI client.

**v1.0.0** The first cross-platform release of the CLI.
- Added: The cfa command-line tool, a single cross-platform Go binary, talks straight to the editor bridge over TCP and ships through npm so it installs anywhere.
- Added: By this point the bridge already covered data tables, materials and material functions, Enhanced Input, blueprints, and level actors, with a cross-platform screenshot that works beyond Windows.

Before this: Same here. A large part of the early command surface was built, used, and reworked well before the first tagged release, back when this was just my own setup for driving the editor from the terminal. The numbers start at 1.0.0, but a lot of the groundwork they sit on came together before that.
<!-- CHANGELOG:END -->

## Documentation pages

Full documentation index. Each page is a real URL with its own content.
<!-- DOCS:START -->
- [Introduction](https://codefizz.dev/docs): What CodeFizz Editor Agent is: a paid Unreal Engine 5 editor plugin plus a free cfa CLI that lets AI assistants build directly inside the editor.
- [Quick Start](https://codefizz.dev/docs/quick-start): Install the cfa CLI, sign in, install the plugin, teach your AI, and verify the editor connection in five commands.
- [Requirements](https://codefizz.dev/docs/requirements): Supported Unreal Engine versions, operating system, CLI runtime, and AI tool requirements for CodeFizz Editor Agent.
- [Installing the CLI](https://codefizz.dev/docs/installation): Install the free cfa command line tool with one PowerShell command or from npm, and keep it updated with cfa self-update.
- [License & Machines](https://codefizz.dev/docs/license): Activate a machine with cfa login (browser account sign-in), check status with cfa whoami, and move seats between machines. License keys stay collapsed as a legacy option only.
- [Installing the Plugin](https://codefizz.dev/docs/guides/plugin): Install, check, update, roll back, and remove the Unreal plugin per engine or project with cfa install-plugin and update-all.
- [The AI Skill](https://codefizz.dev/docs/guides/ai-skill): Install the bundled Agent Skill that teaches your AI assistant how to drive Unreal through cfa, with scope options.
- [CLI vs MCP](https://codefizz.dev/docs/guides/cli-vs-mcp): Both talk to the same plugin. Use the CLI (direct, fast, token efficient); use the MCP server only when your AI cannot run shell commands.
- [Multiple Editors](https://codefizz.dev/docs/guides/editors): Every command targets one editor. Use cfa list_editors, connect, status, and CFA_SESSION to control which editor you drive.
- [How It Works](https://codefizz.dev/docs/guides/how-it-works): The plugin runs a small local bridge inside the editor. The cfa CLI and MCP server connect over a local port; nothing leaves your machine except the license check.
- [Discovering Commands](https://codefizz.dev/docs/guides/commands): Every command follows cfa <command> [--flag value]. Discover them with cfa commands and cfa describe, and understand the toolset model.
- [FAQ](https://codefizz.dev/docs/faq): Frequently asked questions about installing, licensing with browser login, updating, and using CodeFizz Editor Agent.
- [Troubleshooting](https://codefizz.dev/docs/troubleshooting): Fixes for common issues: the plugin failing to load on Unreal 5.8 (GetLastError 126, module could not be loaded), bridge unreachable, wrong editor targeted, license or activation problems, and plugin version mismatches.
- [For AI Agents](https://codefizz.dev/docs/for-ai): Machine-readable summaries of this product and its install steps for AI assistants: llms.txt and llms-full.txt.
- [Build a Blueprint with AI](https://codefizz.dev/docs/walkthroughs/blueprint): A guided example that creates a Blueprint, adds a variable and a function, wires an event graph, and compiles it, all through cfa commands.
- [Author a Material Graph](https://codefizz.dev/docs/walkthroughs/material): A guided example: create a Material and build its node graph in one atomic call, then apply it to an actor.
- [Create a Niagara System](https://codefizz.dev/docs/walkthroughs/niagara): A guided example: create a Niagara system, add an emitter and modules, set inputs, and compile a working effect.
- [Reference](https://codefizz.dev/docs/reference): Every CodeFizz Editor Agent command, organized by category. Search or open a category to see each command with its parameters and an example.
- [Niagara](https://codefizz.dev/docs/reference/niagara): Every Niagara command in CodeFizz Editor Agent, with parameters and examples.
- [PCG](https://codefizz.dev/docs/reference/pcg): Every PCG command in CodeFizz Editor Agent, with parameters and examples.
- [Materials](https://codefizz.dev/docs/reference/materials): Every Materials command in CodeFizz Editor Agent, with parameters and examples.
- [StateTree](https://codefizz.dev/docs/reference/statetree): Every StateTree command in CodeFizz Editor Agent, with parameters and examples.
- [Sequencer](https://codefizz.dev/docs/reference/sequencer): Every Sequencer command in CodeFizz Editor Agent, with parameters and examples.
- [Level Actors](https://codefizz.dev/docs/reference/editor): Every Level Actors command in CodeFizz Editor Agent, with parameters and examples.
- [Project Settings](https://codefizz.dev/docs/reference/projectsettings): Every Project Settings command in CodeFizz Editor Agent, with parameters and examples.
- [Blueprints](https://codefizz.dev/docs/reference/blueprints): Every Blueprints command in CodeFizz Editor Agent, with parameters and examples.
- [Blueprint Structs](https://codefizz.dev/docs/reference/structs): Every Blueprint Structs command in CodeFizz Editor Agent, with parameters and examples.
- [Enhanced Input](https://codefizz.dev/docs/reference/input): Every Enhanced Input command in CodeFizz Editor Agent, with parameters and examples.
- [Asset Management](https://codefizz.dev/docs/reference/assets): Every Asset Management command in CodeFizz Editor Agent, with parameters and examples.
- [Bulk Asset Ops](https://codefizz.dev/docs/reference/asset_ops): Every Bulk Asset Ops command in CodeFizz Editor Agent, with parameters and examples.
- [Data Assets](https://codefizz.dev/docs/reference/dataassets): Every Data Assets command in CodeFizz Editor Agent, with parameters and examples.
- [Object Properties](https://codefizz.dev/docs/reference/objects): Every Object Properties command in CodeFizz Editor Agent, with parameters and examples.
- [UMG Widgets](https://codefizz.dev/docs/reference/widgets): Every UMG Widgets command in CodeFizz Editor Agent, with parameters and examples.
- [Data Tables](https://codefizz.dev/docs/reference/datatables): Every Data Tables command in CodeFizz Editor Agent, with parameters and examples.
- [Curves](https://codefizz.dev/docs/reference/curves): Every Curves command in CodeFizz Editor Agent, with parameters and examples.
- [Console Commands](https://codefizz.dev/docs/reference/console): Every Console Commands command in CodeFizz Editor Agent, with parameters and examples.
- [Profiling](https://codefizz.dev/docs/reference/profiling): Every Profiling command in CodeFizz Editor Agent, with parameters and examples.
- [Core](https://codefizz.dev/docs/reference/core): Every Core command in CodeFizz Editor Agent, with parameters and examples.
- [Debug](https://codefizz.dev/docs/reference/debug): Every Debug command in CodeFizz Editor Agent, with parameters and examples.
<!-- DOCS:END -->

## Links

- Home: https://codefizz.dev/
- Install and usage docs: https://codefizz.dev/docs
- Tools (full command list): https://codefizz.dev/tools
- Demo (embedded videos): https://codefizz.dev/demo
- Roadmap: https://codefizz.dev/roadmap
- YouTube channel: https://youtube.com/@codefizz
- Demo video, full solar system with Niagara: https://youtu.be/8yIMDl0NZwM
- Demo video, procedural forest with PCG: https://youtu.be/dSJUI3CMOds
- Demo video, full UI from materials only: https://youtu.be/aSbcVre5rzk
- Demo video, build materials by typing a prompt: https://youtu.be/O_prPSpTO_c
- Buy the plugin (Polar): https://buy.polar.sh/polar_cl_w7Gi8g9FLUXqNwJvH3xKt74A8y7joYpXNkpGD0KwujH
- Your account (trial, billing, devices; legacy key collapsed): https://codefizz.dev/account
- Free open-source edition (Unreal MCP): https://github.com/aadeshrao123/Unreal-MCP
- npm package: https://www.npmjs.com/package/codefizz-editor-agent
- Discord: https://discord.gg/F92DeSbmaU

## Contact

For studio licensing, bugs, or questions, reach out on Discord or by email through the website footer.