Skip to main content
Glama

generate_parts

Build a rigged 3D model from a front-view concept by generating separate part meshes, assembling them, and creating a one-bone-per-part armature.

Instructions

Build a model as separate part meshes from a front view concept, assembled and rigidly rigged.

parts: one entry per part, {"name": "left_arm", "box": [x0, y0, x1, y1], "parent": optional part name, "description": optional words to tell it apart}. The box is where that part is in concept_image, as fractions of the image (0 to 1) or pixels; look at the image and give a rough box around each part (overlaps are fine). subject names the object ("robot", "stingray"). Each part is cropped, cleaned into a standalone part by FLUX.2 Klein (hidden areas completed) and meshed by TRELLIS.2 with face_count faces. The parts are placed by their boxes, with depth from a whole-object mesh (generated from the concept unless full_mesh, a GLB of it, is given). rig=True adds an armature with one bone per part: the hierarchy follows the parents given, else which parts touch (rooted at the largest part), and each bone pivots where its part meets its parent. Parts are parented rigidly to their bones, the natural rig for robots and other hard surface models. If a run fails part way, call again with the same output_dir: finished parts are reused. Output: an assembled GLB and FBX (each part a separate object), plus every part's image and mesh. About 1 to 2 minutes per part on the GPU.

Tool call template

Replace each placeholder with a value matching the input schema. Only required parameters are included; add optional parameters as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {
      "concept_image": "<concept_image>",
      "parts": "<parts>"
    },
    "name": "generate_parts"
  }
}

Input Schema

NameRequiredDescriptionDefault
rigNo
seedNo
partsYes
subjectNocharacter
full_meshNo
face_countNo
output_dirNo
concept_imageYes
idle_timeout_secondsNo

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv0.1.0

TDQS

A4.1/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full behavioral burden and does a lot: it names the underlying models (FLUX.2 Klein for hidden-area completion, TRELLIS.2 for meshing), explains depth sourcing and the full_mesh override, discloses the bone-pivot and parenting rules, states resumption/reuse semantics, lists output artifacts, and gives a runtime estimate (~1-2 min per part on GPU). Only error modes outside resume (bad box coords, GPU unavailability) go unaddressed.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Purpose is front-loaded in the first sentence, then the description proceeds in pipeline order (parts input -> per-part processing -> placement -> rigging -> resume -> outputs -> timing). It is dense and long, but every sentence carries operational information; there is no filler or restatement of the tool name.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a 9-parameter, multi-stage GPU pipeline with no output schema and no annotations, this is close to complete: inputs, processing stages, assembly, rigging, artifacts produced, and expected duration are all covered. The gaps are the two undocumented knobs (seed, idle_timeout_seconds) and any failure/validation behavior beyond mid-run resumption.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, so the description must compensate, and it does: it documents the parts entry shape (name, box, optional parent, optional description), box units (fractions 0-1 or pixels, overlaps allowed), subject, face_count, rig, full_mesh, output_dir resume behavior, and that boxes are relative to concept_image. Seed and idle_timeout_seconds are left entirely undocumented, which keeps it out of the top band.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The opening line gives a specific verb-resource-scope: builds a model as separate part meshes from a front-view concept, assembled and rigged. That distinguishes it from a single-mesh generator (generate_mesh) and from creature rigging (rig_creature) by the 'separate part meshes' and 'rigidly rigged' framing. It stops short of naming a sibling, so differentiation is inferred rather than stated.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Gives clear situational context: input must be a front-view concept image, and rig=True is framed as 'the natural rig for robots and other hard surface models', implicitly steering organic subjects elsewhere. It also gives a concrete recovery instruction (re-call with the same output_dir after a partial failure). No explicit when-not-to-use or named alternative tool.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.