Character model skill for AI agents

​

When your agent uses it

• Generating a humanoid character ready for animation — player avatar, NPC, enemy, boss, companion
• The user asks for a rigged humanoid or a model with a skeleton

​

Install

npx -y summer-engine@latest skills install character-model --agent claude-code

​

The skill

1. T-pose reference image    →  assets.generate_image                          (~10s)
2. Un-rigged 3D mesh         →  assets.generate_3d(image-to-3d)  → a job       (~60s)
3. ── USER REVIEW GATE ──
4. Rigged .glb               →  assets.generate_3d(image-to-3d, rig) → a job   (~90s)
5. Import → editor RESTART → wire as CharacterBody3D / Node3D
6. Hand off to generate-motion for clips

​

When to use

• “Make a knight character for the player to control.”
• “I need a goblin enemy.”
• “Generate an old wizard NPC for the tavern.”
• “Create a boss — a four-armed demon.”
• The user is about to ask for animations and has nothing rigged yet.

​

When NOT to use

• Static statue / mannequin display piece (no rig needed) → prop-model.
• Vehicle with a “driver” silhouette but no skeleton needed → vehicle-model.
• Quadruped (wolf, horse, dragon) → Meshy auto-rig is humanoid-only. Generate the mesh here for visuals, but skip the rig step — animation will need a hand-authored skeleton or a quadruped-specific provider (out of scope for this skill).
• The user already has a rigged character and just wants a re-skin — that’s a retexture pass, not this skill.
• Facial blendshapes / lipsync rig → facial-and-lipsync.

​

Polycount targets

​

Steps

​

1. Generate the T-pose reference image

assets.generate_image({
  prompt: "A fantasy knight in full plate armor, red cape, T-pose, arms straight out horizontal, legs slightly apart, front-facing, neutral expression. Game character asset, stylized, clean white background, soft studio lighting, full body in frame, ready for 3D mesh generation.",
  model: "nano-banana-2",
  aspectRatio: "3:4"
})

assets.generate_image({
  referenceImageUrl: "<existing concept image>",
  prompt: "<character> in T-pose, arms extended horizontally, neutral facing camera, white background, clean lighting"
})

Generated the T-pose reference. [link]. Approve to proceed to mesh generation, or regenerate?

​

2. Generate the un-rigged 3D mesh

assets.generate_3d({
  kind: "image-to-3d",
  imageUrl: "<image url from step 1>",
  model: "hunyuan",
  targetPolycount: 12000
})
jobs.wait({ jobId: "<job.id>", timeoutSeconds: 50 })   // again until finished

assets.get({ assetId: "<assetId>" })
summer_import_asset_by_id(
  assetId="<assetId>",
  path="res://assets/characters/knight_unrigged.glb"
)

​

3. STOP: USER REVIEW GATE — DO NOT SKIP

Un-rigged knight mesh ready: res://assets/characters/knight_unrigged.glb (~12k tris, [preview link]). Next step is the rig pass (uses credits, ~90s). It locks the topology and adds a skeleton compatible with generate-motion. Once you approve I’ll run it. Approve the mesh and proceed to rig? Or regenerate the mesh first (different prompt, different polycount, different model)?

​

4. Run the rig pass

assets.generate_3d({
  kind: "image-to-3d",
  imageUrl: "<image url from step 1>",
  rig: true,
  targetPolycount: 12000
})
jobs.wait({ jobId: "<job.id>", timeoutSeconds: 50 })   // again until finished

assets.get({ assetId: "<rigAssetId>" })
summer_import_asset_by_id(
  assetId="<rigAssetId>",
  path="res://assets/characters/knight.glb"
)

​

5. WARNING: Restart the editor

The rigged mesh is imported. Please restart the Summer Engine editor (close and reopen) so the Skeleton3D rebuilds correctly. Without the restart, animations will fail to bind.

​

6. Wire as CharacterBody3D or Node3D — pick the right parent

• Every scene tool, summer_run_script included, takes an explicit scenePath, and the scene need not be the active editor tab.
• A character is several nodes: build it in one summer_run_script, not a chain of single calls.
• A .glb is instantiated, not assigned. There is no scene property on Node3D, and an imported .glb is a scene rather than a Mesh — on the shipped 4.6.1 binary ResourceLoader.get_recognized_extensions_for_type("Mesh") returns ["tres", "mesh", "res"], with no glb. Use ctx.instance_scene in a script, or summer_instantiate_scene for one model.

summer_run_script(scenePath="res://main.tscn", source="""
func run(ctx):
    var knight = ctx.add_node("CharacterBody3D", "Knight", ctx.find("World"), {"position": Vector3(0, 0, 0)})
    ctx.instance_scene("res://assets/characters/knight.glb", knight, "Mesh")
    var capsule := CapsuleShape3D.new()
    capsule.height = 1.7
    capsule.radius = 0.4
    ctx.add_node("CollisionShape3D", "Collider", knight, {"shape": capsule})
    ctx.save_scene()
""")

summer_instantiate_scene(scenePath="res://main.tscn", parent="./World/Tavern", scene="res://assets/characters/wizard.glb", name="OldWizard")
summer_save_scene(scenePath="res://main.tscn")

​

7. Hand off to animation

Knight is wired at ./World/Knight with an auto-rigged skeleton. rigAssetId saved. Next: generate-motion to add idle / walk / run / attack clips. Example call: assets.generate_motion(\{ rigAssetId: "<saved id>", backend: "meshy-library", motionNames: ["walk"] \}). For custom actions, use text-to-motion (backend: "text-to-motion").

​

Anti-patterns

• Skipping the user-review gate. Spends the rig credits, locks the design, and removes the user’s chance to course-correct cheaply.
• Generating the mesh from a non-T-pose image. Locomotion will look broken (inverted knees, snapped elbows). Always re-pose first.
• Forgetting the editor restart. Animations will appear to bind successfully but play to a stale skeleton — the character T-poses motionless. The fix is always restart, never code.
• Wrapping a cinematic NPC in CharacterBody3D. Wastes physics ticks; use Node3D.
• Wrapping the player in Node3D. No move_and_slide(), no collision — the player walks through walls.
• Picking the rig pass before approving the silhouette. The mesh defines what the character looks like; once the rig is on, you can’t cheaply iterate the design.
• Using meshy model for the mesh step. Legacy. hunyuan is the default and produces cleaner topology that Meshy’s auto-rig handles better.

​

Edge cases

• Multiple characters share a silhouette. Generate the rig once, then re-skin via texture swap (cheaper than re-rigging): generate a new albedo and assign it as a material override.
• Character has wings, tail, extra limbs. Meshy’s humanoid rig only weights the standard skeleton — extras sag. Either prompt them as static (e.g. cape held by physics in-engine) or hand-rig in Blender post-export.
• Child / dwarf / giant. Generate at correct proportions in the T-pose; the rig retargets cleanly. Locomotion clips from generate-motion will retarget but stride length needs playback_speed tuning on the AnimationPlayer.
• First-person hands-only character. Generate just hands + forearms in T-pose; rig pass still works. See fps-controller for first-person wiring.
• Stylized non-human (goblin, orc, halfling). Works fine as long as the silhouette is bipedal with two arms, two legs, one head. Quadrupeds and centaurs do not.

​

Without Summer Engine

​

Fallback (no MCP)

1. Generate the T-pose reference in the Summer dashboard.
2. Run image-to-3D with rigging enabled in the Summer dashboard.
3. Download the .glb.
4. Drop into res://assets/characters/; Summer Engine’s Import dock picks it up.
5. Restart the editor.
6. Wire as CharacterBody3D / Node3D in Summer Engine manually.

​

Handoff

Knight is at ./World/Knight with an auto-rigged skeleton. Next:

• Animations: generate-motion for idle / walk / run / attack. Pass the rigAssetId returned in step 4.
• State machine: after a few clips exist, animation-tree for idle → walk → run blends.
• Player input: if this is the player, wire WASD + mouse via fps-controller or a third-person controller skill.
• NPC behavior: if it’s an NPC, design-npc for behavior trees and dialogue hooks.
• Re-skin variants (palette swap, armor swap): retexture pass — generate new albedo, assign via material override. Avoid re-rigging.

​

See also

• generate-motion — the next-step animation skill that consumes the rigAssetId produced here.
• asset-strategy — meta-router; this skill is the canonical drill-down of its “Image-to-3D for characters” path.
• prop-model — for non-character props.
• scene-composition — for the CharacterBody3D + Mesh + Collider parent pattern.
• summer_docs_read id reference/mcp-tools-reference — how to call assets.generate_3d, assets.generate_image and assets.generate_motion; summer_search returns each one’s exact input.

​

From a shell

​

Related skills

• prop-model: Generate one static 3D prop (sword, barrel, chest, lantern, statue): one object, no rig, a MeshInstance3D.
• vehicle-model: Generate a hard-surface vehicle (car, spaceship, mech, boat, tank) as a static or VehicleBody3D mesh.
• design-npc: Design enemy, NPC, boss or companion behavior: perception, state machine, telegraphs, script stub.
• animation-tree: Wire AnimationTree state machines and blend trees: locomotion blends, attack interrupts, hit reactions.
• facial-and-lipsync: Make a character’s mouth move with a voice-over: phonemes, viseme blendshapes, facial expressions.
• generate-motion: Attach a library animation clip (idle, walk, run, attack) to a rigged character via AnimationPlayer.
• procedural-animation: Runtime bone changes on top of clips: head look-at, foot IK, hand grabs a prop, lean, recoil.
• asset-strategy: Route any ‘I need a [thing]’ asset request to the right skill: 2D, 3D, audio, video, VFX or animation.
• fps-controller: First-person controller: WASD, mouse look, jump, coyote time, jump buffering, air control.
• organic-model: Generate organic 3D shapes (trees, rocks, mushrooms, plants, crystals) where irregularity looks natural.