CodeFizz
ToolsDemoDocsBlogRoadmapChangelogPricingCompareFAQ
Get the plugin

Getting Started

  • Introduction
  • Quick Start
  • Requirements
  • Installing the CLI
  • License & Machines

Guides

  • Installing the Plugin
  • The AI Skill
  • CLI vs MCP
  • Multiple Editors
  • How It Works
  • Discovering Commands
  • The Editor Chat Panel
  • Image Generation (OpenRouter)

Walkthroughs

  • Build a Blueprint with AI
  • Author a Material Graph
  • Create a Niagara System
  • Rig a Character with AI
  • Build an Animation Blueprint
  • Build Sound with AI
  • Build a Modular Character
  • Grow a Tree with AI
  • Build a Gameplay Ability System
  • Generate a Landscape with AI
  • Work with World Partition

Reference

  • Reference
  • Audio
  • Mutable
  • Control Rig
  • Niagara
  • PCG
  • Procedural Vegetation
  • Materials
  • Gameplay Ability System
  • World Building
  • Behavior Trees
  • Environment Queries
  • StateTree
  • Sequencer
  • Level Actors
  • Project Settings
  • Blueprints
  • Blueprint Structs and Enums
  • Enhanced Input
  • Asset Management
  • Bulk Asset Ops
  • Data Assets
  • Object Properties
  • UMG Widgets
  • Data Tables
  • Curves
  • Retargeting
  • Skeletal Meshes
  • Animation
  • Chooser Tables
  • UAF (Animation Framework)
  • Console Commands
  • Revision Control and Asset Diff
  • Profiling
  • Image Generation
  • Core
  • Debug
  • Mass Entity (ECS)

Help

  • FAQ
  • Troubleshooting
  • For AI Agents
  • Fix: Plugin failed to load, module could not be loaded (GetLastError 126)
  • Fix: bridge unreachable, editor not responding
  • Fix: cfa targeted the wrong Unreal editor
  • Fix: the CodeFizz panel does not show Active
  • Fix: Unknown command, or plugin version mismatch after an update
DocsReferenceCore

Core

Every Core command in CodeFizz Editor Agent, with parameters and examples.

Loading…
PreviousImage GenerationNextDebug
CodeFizz

A drop-in Unreal Engine 5 plugin that exposes the entire editor surface (Blueprints, Materials, Niagara, PCG, StateTree, Control Rig, Insights profiling, and more) over the Model Context Protocol. Connect Claude Code, Cursor, VS Code, or any MCP-compatible client and let your AI build inside the engine.

Product

  • Features
  • Docs
  • Tools
  • Blog
  • Demo
  • Roadmap
  • Changelog
  • Pricing
  • Compare
  • FAQ

Resources

  • Install guide
  • Discord
  • YouTube
  • Open-source edition
  • Manage subscription

Legal

  • Refund Policy
  • Privacy Policy
  • Terms of Service

© 2026 CodeFizz. All rights reserved.

CodeFizz Editor Agent is a CodeFizz product. Payments processed by Polar Software, Inc. (Polar), the Merchant of Record.

10 commands. Each shows its parameters and an example, and has a copyable deep link, so you (or an AI agent) can jump straight to one.

health_check

Report CLI, license, and editor-bridge status

Reports three independent layers and never fails just because no editor is open: (1) the CLI itself, (2) your license status (active/trial/expired, email, expiry) read offline from the shared store, and (3) the editor bridge - best-effort probe of the editor this folder targets, with a clear next step (open the project or 'cfa launch') when none is connected. 'healthy' reflects CLI + license only. Run this first to verify your setup.

example
cfa health_check
execute_python

Execute arbitrary Python code inside the running Unreal Editor

Runs Python code in the editor's Python environment where the 'unreal' module is pre-imported. Set a variable named 'result' to return structured data back. Use for operations not covered by other commands.

ParameterTypeRequiredDescription
codestringYesPython code to execute (set 'result' variable to return data)
example
cfa execute_python --code "result = str(unreal.EditorAssetLibrary.list_assets('/Game'))"
dump_command_schema

Dump the C++ reflection-generated schema for reflected commands

Returns the JSON Schema generated from each reflection-backed command's C++ param USTRUCT (the single source of truth). With --name, returns one command's schema; otherwise returns every registered reflected command's schema. Used to keep the Go CLI specs in sync with the C++ structs (see the schema-drift test).

ParameterTypeRequiredDescription
namestringNoOptional: a single reflected command name to dump (omit for all)
example
cfa dump_command_schema --name build_pcg_graph
list_editors

List every running Unreal editor (pid, project, engine, port)

Lists all Unreal editors currently running with the plugin: their pid, project name, full .uproject path, engine path, engine version, and bridge port. Use this to see what is running before connecting. Each command you run targets exactly one editor; use connect_editor to choose which.

example
cfa list_editors
connect_editor

Select which running editor later commands talk to

Selects a running editor as the active target for subsequent commands (persisted, so it survives across separate terminals/processes). Choose by project name (e.g. --project jiggi, accepts 'jiggi' or 'jiggi.uproject') or by --port. Run list_editors first to see the choices. Use this when several editors are open, or when running from a folder that isn't inside the project.

ParameterTypeRequiredDescription
projectstringNoProject name to connect to (e.g. jiggi or jiggi.uproject)
portintNoConnect by exact bridge port instead of project name
example
cfa connect jiggi
  cfa connect_editor --project jiggi
  cfa connect_editor --port 55557
disconnect_editor

Clear the active editor selection

Clears the persisted editor selection set by connect_editor. After disconnecting, commands fall back to auto-detection (the current project's editor, or the single running editor) and refuse with a list when the choice is ambiguous.

example
cfa disconnect
connection_status

Show the active selection and which editor commands would hit

Shows the running editors, the current selection (if any), the current-folder project, and which editor a command would connect to right now (with the reason), or why it would refuse. Use this to understand routing before running other commands.

example
cfa connection_status
get_project_context

Live facts about this editor and project in one read

Engine version, platform and RHI, project name, path, engine association and open map, the compile-time capabilities of this plugin build (profiling, 5.7+, 5.8+), enabled plugins (or a yes/no check of the names you pass), and the asset inventory by class under a content path. get_skill_context uses it to fill the bundled skill.

ParameterTypeRequiredDescription
pluginsstringNoComma-separated plugin names to check as enabled or not; empty lists every enabled plugin up to max_plugins
max_pluginsintNoCap on enabled plugin names listed when plugins is empty (0 = count only)
asset_pathstringNoContent path whose assets are counted by class
max_asset_classesintNoHow many asset classes to report, most numerous first (0 skips the inventory)
example
cfa get_project_context
  cfa get_project_context --plugins IKRig,Water --max-asset-classes 10
get_skill_context

The bundled skill page with live facts from the running editor filled in

Reads one page of the bundled skill (SKILL.md or a reference page) and fills its {{tokens}} from the running editor in one round trip: engine version, project and open map, the plugins the page cares about, the commands unavailable on this engine version or without a plugin, the project's assets by class, and per-page extras such as the Niagara module list. With no editor running it returns the static page with the fallback text, and says why.

ParameterTypeRequiredDescription
pagestringNoSKILL (default) or a reference page name such as niagara, sequencer, retargeting
example
cfa get_skill_context
  cfa get_skill_context --page niagara
list_skill_templates

The substitution tokens the bundled skill uses and which pages carry them

Lists every {{token}} get_skill_context can fill, what each one means, the static fallback text skill install writes, and the pages that use it.

example
cfa list_skill_templates