CodeFizz
ToolsDemoDocsRoadmapChangelogPricingFAQ
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

Walkthroughs

  • Build a Blueprint with AI
  • Author a Material Graph
  • Create a Niagara System
  • Rig a Character with AI

Reference

  • Reference
  • Control Rig
  • Niagara
  • PCG
  • Materials
  • StateTree
  • Sequencer
  • Level Actors
  • Project Settings
  • Blueprints
  • Blueprint Structs
  • Enhanced Input
  • Asset Management
  • Bulk Asset Ops
  • Data Assets
  • Object Properties
  • UMG Widgets
  • Data Tables
  • Curves
  • Console Commands
  • Profiling
  • Core
  • Debug

Help

  • FAQ
  • Troubleshooting
  • For AI Agents
DocsWalkthroughsRig a Character with AI

Rig a Character with AI

A guided example: create a Control Rig from a Skeletal Mesh, build the control hierarchy, fit control shapes to the mesh, wire two bone IK with a pole vector, add jiggle physics, and run the validation gates.

Loading…
PreviousCreate a Niagara SystemNextReference
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
  • Demo
  • Roadmap
  • Changelog
  • Pricing
  • 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.

This walkthrough rigs a character from a Skeletal Mesh: create the Control Rig, build the control hierarchy, fit the control shapes to the mesh, wire a two bone IK limb with a pole vector, add secondary motion, and run the validation gates. Every command in the family is listed in the Control Rig reference.

1

Create the rig from a mesh

Point at a Skeletal Mesh and the rig is born with that skeleton's bones already in its hierarchy.

bash
cfa create_control_rig_from_skeleton --asset-path /Game/Rigs/CR_Hero --skeleton-path /Game/Chars/SKM_Hero
2

Build the control hierarchy

Add controls, nulls, and sockets in one atomic call, each born with its parent, offset, and shape already set.

bash
cfa build_rig_hierarchy --asset-path /Game/Rigs/CR_Hero --elements @hierarchy.json
3

Fit the control shapes

Size every gizmo from the mesh skinned to its bone, instead of leaving them all at the library default.

bash
cfa fit_rig_control_shapes --asset-path /Game/Rigs/CR_Hero
4

Build the solve graph

Place and wire the nodes in one batch. Fan work out of a Sequence and call library functions rather than building one long rail.

bash
cfa build_rig_vm_graph --asset-path /Game/Rigs/CR_Hero --nodes @nodes.json --connections @links.json
5

Place the pole vector

Push the pole control out along the limb's own bend plane so the knee or elbow has a direction to bend in.

bash
cfa place_rig_pole_vector --asset-path /Game/Rigs/CR_Hero --control pole_knee_l --root-bone thigh_l --mid-bone calf_l --end-bone foot_l
6

Add secondary motion

Give hair, a tail, or cloth a jiggle chain, with colliders fitted to the body it rests against.

bash
cfa add_rig_jiggle_bob --asset-path /Game/Rigs/CR_Hero --chain-root hair_01 --chain-end hair_06
7

Validate before you animate

Five gates: the graph, the controls, the gizmos, the deformation, and the physics.

bash
cfa validate_rig_graph --asset-path /Game/Rigs/CR_Hero
8

Prove it moves

Run the rig headless over an animation and report what actually moved, what crossed, and what went through the floor.

bash
cfa simulate_rig --asset-path /Game/Rigs/CR_Hero --animation-path /Game/Anims/Run --frames 60
Modular rigs work the same way
Instead of building the graph yourself you can assemble a rig from Epic's module library: add arm, leg, and spine modules with add_rig_module, wire them with auto_connect_rig_modules, and mirror a limb to the other side with mirror_rig_module. Fit the control shapes after the final compile, because module construction respawns the controls.
Read the result, not just the status
A validation pass returns a verdict of pass, pass_with_warnings, or fail. Read that rather than the health flag, which also goes false on cosmetic warnings. Exact parameters for any command are in the Control Rig reference, or run cfa describe place_rig_pole_vector.