Generating 3D models from Claude with Meshy and Tripo

Guides · ~8 min read · 19 April 2026

godot-catalyst

by Fireal Software · ~8 min read

You’re two hours into a prototype. The gameplay loop is there. You need a sword, a shield, and a health potion. Nothing fancy — placeholder art that’s better than a gray cube but not worth spending an afternoon modeling. Programmer art.

This is the sweet spot for AI 3D generation. Meshy and Tripo turn a text prompt into a game-ready FBX in a few minutes. Godot Catalyst lets Claude kick off generations mid-session, import the results, and place them in your scene without you opening a browser.

The three tools

src/tools/ai-asset-tools.ts exposes three tools:

• godot_generate_3d_model — Meshy or Tripo text-to-3D
• godot_generate_texture — placeholder (points to CC0 alternatives; real image AI hasn’t been wired yet)
• godot_generate_sound — placeholder (same; points to Kenney’s CC0 sounds)

The live one is 3D model generation. Texture and sound are stubs that tell Claude to use godot_search_ambientcg or godot_search_kenney instead. The reason: CC0 libraries already cover textures and sound effects well. A mid-range Meshy or Tripo subscription costs less than generating equivalent-quality textures via Stability/Replicate, and the quality advantage of custom generation over a good CC0 library is narrow for most prototype art.

3D is the exception. There’s no equivalent to Kenney for “give me exactly this specific weapon at this specific style”. You generate or you model.

Setting up an API key

Two providers supported. You pick one:

• Meshy — https://meshy.ai. Better for stylized characters and props. Good retry behavior, decent mesh topology. API docs at api.meshy.ai/v2/text-to-3d.
• Tripo — https://tripo3d.ai. Better for photoreal assets. Newer, slightly rougher API. Docs at api.tripo3d.ai/v2/openapi/task.

Set the corresponding env var in your MCP client config:

{
  "mcpServers": {
    "godot": {
      "command": "npx",
      "args": ["godot-catalyst"],
      "env": {
        "GODOT_PROJECT_PATH": "/path/to/project",
        "MESHY_API_KEY": "msy-..."
      }
    }
  }
}

Or TRIPO_API_KEY if you’re on Tripo. Both providers have free tiers with per-month generation caps. Meshy’s free tier gets you ~200 generations/month.

The generation flow

Ask Claude “generate a low-poly medieval sword for my player to hold”.

1. Claude calls godot_generate_3d_model({"prompt": "low-poly medieval sword", "style": "game-ready"})
2. The tool hits https://api.meshy.ai/v2/text-to-3d with the prompt
3. Meshy accepts the job, returns a task_id
4. The tool responds with {"provider": "meshy", "status": "submitted", "task_id": "..."}
5. Claude reports “kicked off generation, task ID X, takes ~3 minutes”

The generation itself is async. Meshy’s preview mode takes 1-3 minutes, refined mode takes 10+. The tool doesn’t poll — it returns immediately with the task ID and lets you check progress manually (or tells Claude to retry a status call later).

This is deliberate. Long-running generations would either block the MCP session for minutes or need a background polling mechanism, both worse than “submit and check”. Claude is comfortable with the “come back later” pattern.

Checking generation status

No dedicated tool for polling yet. Use godot_create_http_request from the networking category to hit Meshy’s status endpoint:

GET https://api.meshy.ai/v2/text-to-3d/{task_id}
Authorization: Bearer <MESHY_API_KEY>

Claude can make this call, read the status field, and either report “still processing” or grab the download URL. Once status: "SUCCEEDED", the response includes model_urls.glb (and .fbx, .obj, .usdz).

Tripo’s flow is similar: GET https://api.tripo3d.ai/v2/openapi/task/{task_id}, check data.status, pull data.output.model.

Importing the generated model

Once you have the URL, godot_download_asset grabs the file:

godot_download_asset({
  "url": "https://assets.meshy.ai/.../model.fbx",
  "dest_dir": "<project>/models/weapons/"
})

The allowlist in src/assets/providers.ts currently covers Poly Haven, AmbientCG, and Kenney — you’ll need to add your provider’s asset host (e.g. assets.meshy.ai) to download from it. Fork the config or use godot_create_http_request + file write for now.

After the FBX lands on disk, Godot’s importer picks it up. Call godot_reimport_asset to force a rescan if the editor doesn’t notice.

Default FBX import settings work for most generated models, but you’ll want to check:

• Meshes > Save to File — off by default. Turn on if you want to reference the mesh independently of the FBX (useful for pooled weapons).
• Nodes > Root Type — defaults to Node3D. For a weapon you’ll want Node3D + a MeshInstance3D child; for a character, Node3D with Skeleton3D.
• Materials > Use External — off by default. Turn on if you want to edit the materials in Godot instead of having them bundled inside the .fbx.

godot_get_import_settings reads current values; the settings are in .godot/imported/ per-asset.

Prompt design that actually works

Generic prompts give generic results. “A sword” returns something mediocre. “Low-poly medieval longsword with leather-wrapped grip, steel guard, straight blade, game-ready” gets you something usable on the first try.

What actually moves the needle:

• Poly count hint: “low-poly”, “mid-poly”, “high-poly”. Meshy and Tripo both respect this. Low-poly = 500-2000 tris, mid = 2000-10000, high = 10000+.
• Style hint: “cartoon”, “realistic”, “stylized”, “pixel-art-3D”, “toon”. Meshy’s art_style parameter accepts "realistic", "cartoon", "low-poly", "game-ready" (the default Godot Catalyst sets if you don’t specify).
• Context: “for a 2D platformer sidescroller” or “for a first-person RPG”. The model uses this to pick proportions and detail level.
• Material hints: “steel blade”, “wooden handle”, “leather grip”. Split materials generate cleaner separation, making it easier to tweak individual surfaces in Godot.

Avoid:

• Overcomplicated scenes: “a medieval tavern with a bar, tables, barrels, and a fireplace” will generate one awkward blob. Make each item separately.
• Animation prompts: “a sword being swung” generates a static mesh, not an animation. Animations are a separate, rarer category of AI generation.
• Text on the model: “a sign that says STOP” mostly fails. Use a plain mesh + a TextMesh node in Godot.

Use cases that actually work

Prototype weapon packs. Generate 10 variations of “low-poly fantasy sword” in five minutes, pick the three best, use as placeholder art until you commission real models.

Environmental kit-bash. Generate rocks, trees, bushes, crates, barrels. Mix with Kenney assets for a unified prototype look.

Character silhouettes. Generate a low-poly humanoid to block out character scale before the real art pipeline lands. Swap later.

Hero items for one-off scenes. A unique item for a cutscene that doesn’t appear elsewhere. Perfect AI generation target — low reuse, low polish bar, just needs to fill the slot.

Use cases that fail

Characters with faces. AI 3D generation is still rough at faces. Eyes don’t line up, mouths are approximations. For anything the camera gets close to, model or commission.

Anything needing clean topology. AI-generated meshes have weird edge loops, occasional holes, and quads in places quads shouldn’t be. Fine for static props, bad for anything that needs to deform (rigged characters, cloth).

Specific, named IP. “Minecraft sword” will generate something that looks close but not quite right. Legal issues aside, the training data dilutes the specificity.

Pixel-style 3D. AI generators favor smooth meshes. Voxel-style or chunky pixel 3D is hard to prompt into consistently.

Costs

Meshy: $20/month for “Pro” (200 generations, commercial rights). $60/month for “Max” (unlimited refinements, priority queue).

Tripo: Free tier gives ~100 generations/month. Pro is $20/month for more + commercial rights.

Both are well under the cost of commissioning custom models for prototype work. Neither is a replacement for real art pipelines on shipped games — the quality gap is real and widens as you polish.

The tool is a placeholder for texture/sound

godot_generate_texture and godot_generate_sound currently return “info” responses that point Claude at CC0 alternatives. Wiring real image/audio AI APIs is planned. Until then, the CC0 search tools (godot_search_ambientcg, godot_search_polyhaven, godot_search_kenney) cover most texture and SFX needs for free and return better quality than current AI-generated equivalents anyway.

Set MESHY_API_KEY or TRIPO_API_KEY in your MCP client’s env block.