Skip to main content
Glama
CLO Atelier

CLO Atelier

by benproj

CLO Atelier

A Claude plugin and MCP server for CLO 3D. With it, Claude can work in a CLO session you have open: it reads the scene, drafts pattern pieces, sews them, puts fabric on them, runs the simulation, takes screenshots to check the drape, and exports files.

I made this for my own pattern work. It is unofficial and has no connection to CLO Virtual Fashion, who own the CLO name. You need your own CLO license.

What it can do

You can ask for "load this avatar and make a straight skirt in denim", "sew the side seams and simulate", "show me the back view" or "export the garment as GLB". The tools for creating pieces and sewing take lists, so Claude can build a whole garment in a few calls.

Tool

What it does

clo_status

Bridge and CLO version, open project, object counts

clo_get_scene

Every pattern (size, fabric, arrangement, seams), fabrics, colorways, avatars

clo_get_patterns

Outline points and line indices/lengths for some or all patterns

clo_list_arrangement_points

Avatar arrangement points, filterable by name

clo_create_patterns

Create several pieces at once, each with name, fabric, layer and arrangement point

clo_add_internal_shape

Internal line or shape inside a pattern

clo_edit_pattern

Rename, move, flip, re-arrange, fabric, layer, grain, mesh density, freeze, hide

clo_copy_pattern

Duplicate a piece, optionally mirrored

clo_delete_patterns

Delete pieces

clo_sew

Create several seams at once; warns when the two lines differ in length

clo_simulate

Run N steps, optionally switching quality preset or resetting arrangement

clo_screenshot

Several views in one call: 3D standard views and a 2D pattern layout

clo_add_fabric, clo_assign_fabric, clo_get_fabric, clo_edit_fabric

Load, assign, inspect, rename, recolour or replace fabrics

clo_colorways

List, copy, rename, switch colorways

clo_new_project, clo_open_file

Start fresh; open or import a file by path

clo_export

zprj, zpac, obj, fbx, glb, gltf, dxf, pattern JSON, tech pack, turntable, avatar

clo_undo, clo_redo

Step back and forward through the changes the tools made

clo_history

List those changes, or label a checkpoint to return to by name

clo_search_api

Keyword search over CLO's 600+ Python API functions and option structs

clo_execute_python

Run any Python inside CLO (persistent namespace)

clo_stop_bridge

Stop the bridge

Related MCP server: clo3d-mcp

Undo

CLO's Python API has no undo call. CLO does put most API changes on its own undo stack (the History panel), but it skips some, such as moving a piece or changing its layer, and a script can't read that list or jump to a point in it.

So the server keeps its own history. Before any tool call that changes the garment, it saves the garment to a file under ~/.clo-mcp/history/. clo_undo loads the save from before the last change, or from several changes back, and clo_redo goes forward again. An undo brings back patterns, seams, fabrics, colorways and the simulated drape, so you can undo a simulation that went wrong. clo_history shows the list and can label a checkpoint, for example "before sleeves", that clo_undo returns to by name.

Each save adds roughly half a second to a tool call, and an undo takes about three seconds. The history keeps the last 25 changes and starts over each time CLO is launched. Three things to know:

  • The avatar and scene are not saved, only the garment.

  • An undo also throws away what you changed by hand in CLO after that point. clo_redo brings it back if you haven't made another change since.

  • Loading a save clears the list in CLO's own History panel.

Requirements

  • CLO with the Python Script editor. I built and tested this on CLO Standalone 2025.0 for macOS. I have not tried it on Windows.

  • Node.js 18 or later

  • Claude Code, or another MCP client

Install

As a Claude Code plugin, inside a session:

/plugin install clo-atelier --marketplace benproj/clo-atelier

or from your shell:

claude plugin marketplace add benproj/clo-atelier
claude plugin install clo-atelier@clo-atelier

Or as a plain MCP server for any client:

git clone https://github.com/benproj/clo-atelier.git
cd clo-atelier
npm ci
claude mcp add clo3d -- node "$PWD/server/index.js"

Start the bridge in CLO

CLO only lets Python that runs inside the application use its API. So there is a small bridge script, and you start it once each time you launch CLO:

  1. In CLO, open Edit > Python Script.

  2. Paste this line into the editor and press Run (the play button):

    import os; exec(open(os.path.expanduser("~/.clo-mcp/clo_mcp_bridge.py")).read())
  3. The editor's output shows [clo-mcp] Bridge 0.1.0 listening on 127.0.0.1:9877.

On macOS there is a shortcut that does those steps for you:

bash ~/.clo-mcp/start-bridge.sh

It launches CLO if it isn't open, opens the Python editor, pastes the line and presses Run by sending clicks and keystrokes through System Events. The first time, macOS asks you to allow your terminal under Privacy & Security > Accessibility. The script replaces whatever text is in CLO's Python editor and borrows the clipboard for a second before putting your clipboard back. Claude can run it too: when the bridge is down, the tools reply with this command.

The server copies the bridge and this script to ~/.clo-mcp/ when it first starts, so open your MCP client once before any of this. If the bridge isn't running, each tool answers with these instructions. To stop the bridge, press Run a second time or call clo_stop_bridge.

How it works and what it touches

MCP client ──stdio──▶ server/index.js ──localhost TCP──▶ bridge/clo_mcp_bridge.py (inside CLO)

The bridge runs on CLO's main thread and uses only the Python standard library. It listens on 127.0.0.1, runs the Python the server sends, and pumps Qt events between requests so you can keep using CLO while it runs.

When the bridge starts it writes its port and a random token to ~/.clo-mcp/bridge.json, readable only by you. The server reads that file before every request, so another user on the machine can't reach the bridge.

clo_execute_python runs whatever Python it is given inside CLO, with your permissions. The other tools work the same way with fixed snippets. Connect only MCP clients you trust.

The tools read and write the file paths you or Claude give them for imports, exports and screenshots. Beyond those they write temporary screenshot files and the ~/.clo-mcp/ folder, which also holds the undo history. The only network traffic is the local socket between the server and CLO, and there is no telemetry.

The server depends on the official MCP SDK and zod, both pinned in package-lock.json. clo_search_api reads the API stub files inside your CLO installation (Contents/Resources/ApiStubFiles), so its results match your CLO version, and it works when CLO is closed.

Configuration

Variable

Used by

Purpose

CLO_MCP_PORT

bridge

First port to try (default 9877; tries the next 9 if busy)

CLO_APP_PATH / CLO_API_STUBS

server

Where to find CLO's API stubs if not auto-detected

CLO_MCP_HISTORY

server

Set to 0 to switch the undo history off

CLO_MCP_HISTORY_SIZE

server

How many changes to keep (default 25)

CLO_MCP_STATE_FILE

server

Location of the bridge state file (default ~/.clo-mcp/bridge.json)

Limits

  • Undo covers the garment only. clo_new_project and opening a .zprj replace the avatar and scene too, so export a .zprj first if you care about them.

  • CLO can't do anything else while a request runs, which you will notice during long simulations.

  • Some API calls open a dialog in CLO, and CLO then ignores the bridge until you close it. Tools called in the meantime fail within a few seconds and say why. The built-in tools pass option structs to skip the dialogs I found.

  • The API can't select objects, move the 3D gizmo, or edit avatars.

Development

npm ci
npm test                              # real server + bridge against a mock of CLO's API
node test/call.mjs clo_status         # call one tool against a live CLO
node test/undo_live.mjs               # undo, redo and checkpoints against a live CLO
node test/live.mjs /tmp/clo-live      # full smoke test; starts a new project in CLO, so save first

License

MIT

Available Tools

26 tools
clo_add_fabricAdd a fabricA

Load a fabric file (.zfab, .jfab) into the project's fabric list and optionally assign it to pattern pieces. CLO's bundled fabrics are in ~/Documents/clo/CLO Assets/Fabric (denim, jersey knits, organza, velvet, ...).

Inputs: file_path (required), assign_to_patterns.

clo_add_internal_shapeAdd an internal line or shapeB

Draw an internal line or closed internal shape (dart, fold line, pocket placement, cut-out guide) inside an existing pattern piece.

Inputs: points (required), pattern_index (required), closed.

clo_assign_fabricAssign a fabric to patternsB

Apply a fabric already in the project to pattern pieces.

Inputs: fabric_index (required), pattern_indices (required), scope.

clo_colorwaysList or change colorwaysA

List the project's colorways, and optionally add one by copying, rename one, or switch the active one. With no arguments it only lists. Operations run in the order copy, rename, switch.

Inputs: rename, copy_from, switch_to.

clo_copy_patternCopy a pattern pieceA

Duplicate a pattern piece, placing the copy's centre at a position in the 2D window. Optionally mirror the copy, e.g. to make a right sleeve from a left one. Returns the new piece's index.

Inputs: center (required), pattern_index (required), flip, name.

clo_create_patternsCreate pattern piecesA

Draw one or more new pattern pieces from ordered outline points (each outline closes back to its first point). Create all pieces of a garment in one call. Coordinates are absolute positions in the 2D window, so give each piece its own area or they overlap. Returns each new piece's index and its outline lines (index, length), ready for clo_sew.

Inputs: patterns (required).

clo_delete_patternsDelete pattern piecesA
Destructive

Delete pattern pieces, along with their seams. Cannot be undone. Remaining pieces are renumbered, so re-read indices with clo_get_scene afterwards.

Inputs: pattern_indices (required).

clo_edit_fabricEdit a fabricA

Change a fabric in the project: rename it, set its base colour (tints any texture), or replace it with a different fabric file while keeping its assignments. Set only the fields you want changed.

Inputs: fabric_index (required), name, color, replace_with_file.

clo_edit_patternEdit a pattern pieceA

Change properties of an existing pattern piece. Set only the fields you want changed: rename, move in the 2D window, flip, re-place on the avatar, change fabric, layer, grain, mesh density, or freeze/hide it in 3D.

Inputs: pattern_index (required), flip, name, layer, +7 more.

clo_execute_pythonRun Python in CLOA

Run Python inside CLO on its main thread, for anything the other tools do not cover. In scope: utility_api, pattern_api, fabric_api, import_api, export_api, rest_api, ApiTypes (option structs such as ApiTypes.ImportExportOption()), json and os. Variables persist between calls. Returns the value of the last expression, or of a variable named result, plus anything printed. Look functions up with clo_search_api first.

Inputs: code (required), timeout_s.

clo_exportSave or export the projectA

Write the current work to disk, overwriting any file at that path. zprj saves the whole project; zpac the garment only; obj/fbx/glb/gltf the 3D mesh; dxf the 2D patterns; pattern-json CLO's pattern data; techpack a .json with images alongside; turntable a rotating image sequence (give a .png path); avatar an .avt.

Inputs: format (required), file_path (required), timeout_s, include_avatar, +1 more.

clo_get_fabricGet fabric detailsB
Read-only

Properties of one fabric in the project: name, material and physical information, width, base colour and texture paths.

Inputs: fabric_index (required).

clo_get_patternsGet pattern geometryA
Read-only

Outline geometry for one or more pattern pieces: points (mm), outline lines with index, length and whether curved, plus fabric, grain, layer, mesh particle distance, arrangement and seam groups. Use it to find line indices and matching lengths before sewing. Omit pattern_indices for every piece.

Inputs: pattern_indices.

clo_get_sceneDescribe the CLO sceneA
Read-only

Summarise the open project in one call: every pattern piece (index, name, fabric, centre position, size, arrangement point, seam groups), fabrics, colorways, avatars and simulation quality. Use clo_get_patterns for outline points and line indices.

Inputs: no named parameters.

clo_historyShow or mark the edit historyA

List the changes that can be undone or redone, newest first, with the tool call that made each. Pass checkpoint to mark the current state with a label (for example before trying a design variation), so clo_undo can return to it by name. History covers this CLO launch and keeps the most recent 25 changes.

Inputs: checkpoint.

clo_list_arrangement_pointsList avatar arrangement pointsA
Read-only

List the arrangement points around the loaded avatar (index and name), which place pattern pieces near a body part before simulation. Returns nothing if no avatar is loaded.

Inputs: filter.

clo_new_projectStart a new projectA
Destructive

Clear the current garment and start a new one. Unsaved work is lost; export a .zprj first if it matters.

Inputs: no named parameters.

clo_open_fileOpen or import a fileA

Open a file in CLO by path. A project (.zprj) replaces the current scene, discarding unsaved work. Avatars (.avt), garments (.zpac), fabrics (.zfab), DXF patterns, OBJ/FBX/glTF meshes and other supported formats are added to it using CLO's defaults. Bundled avatars are in ~/Documents/clo/CLO Assets/Avatar.

Inputs: file_path (required), timeout_s, add_to_scene.

clo_redoRedo undone changesA

Reapply changes that clo_undo just undid. Only available until the next tool call that changes the project.

Inputs: force, steps.

clo_screenshotLook at the garmentA
Read-only

Capture images of the scene so you can see it. Ask for several views in one call. 3D views other than current move the user's camera. 2d-patterns is a flat layout of the pattern pieces as drawn in the 2D window; the number labels restart for each fabric and are not pattern indices.

Inputs: views, save_dir.

clo_search_apiSearch CLO Python APIA
Read-only

Search CLO's Python API reference (read from the installed CLO application) by keyword. Returns matching function signatures with their documentation, and matching option struct types. Works without CLO running.

Inputs: query (required), limit, module.

clo_sewSew pattern lines togetherA

Create seams, each joining an outline line on one piece to an outline line on another (or the same) piece. Pass every seam of the garment in one call. Get line indices from clo_create_patterns or clo_get_patterns. The two lines are joined start-to-start by default; set direction_b false when line B runs the opposite way along the seam, otherwise the seam twists.

Inputs: seams (required).

clo_simulateRun the drape simulationA

Simulate the garment for a number of steps. CLO is busy until it finishes; follow with clo_screenshot to see the result. Around 100-200 steps settles a simple garment.

Inputs: steps, quality, timeout_s, reset_arrangement.

clo_statusCLO statusA
Read-only

Check that CLO is running with the bridge loaded. Returns CLO version, open project, and counts of patterns, fabrics, colorways and avatars. Call this first.

Inputs: no named parameters.

clo_stop_bridgeStop the CLO bridgeA

Stop the bridge script inside CLO. The other tools stop working until the user runs the bridge script again, so only call this when the user asks.

Inputs: no named parameters.

clo_undoUndo changesA

Undo the last tool call that changed the project, or several, by restoring the garment as it was before. Works for everything the tools change, including simulation, moves and deletions: patterns, seams, fabrics, colorways and the 3D drape all come back. It also discards anything the user changed by hand in CLO since that point (clo_redo brings it back). The avatar and scene are not part of the history. Restoring resets the list in CLO's own History panel.

Inputs: force, steps, to_checkpoint.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.7/5.0

    Scored across 26 tools

    Disambiguation4/5

    Most tools map to a single distinct resource+action, and the descriptions actively steer the agent (clo_get_scene vs clo_get_patterns, clo_add_fabric vs clo_assign_fabric, clo_undo/redo/history). The main soft spots are clo_open_file, which can also add fabrics/avatars that clo_add_fabric handles, and clo_colorways, which bundles list/copy/rename/switch into one tool, but both are explained well enough to avoid misselection.

    Naming Consistency4/5

    Nearly all tools use a consistent clo_verb_noun snake_case pattern with a clear domain prefix. Deviations are minor: noun-only names like clo_status, clo_export, clo_colorways, clo_history, and singular/plural drift (clo_edit_pattern vs clo_get_patterns/clo_delete_patterns).

    Tool Count3/5

    26 tools is on the heavy side of the scale, though a full 3D garment CAD application genuinely has many distinct operations. A few clusters (three fabric tools, three undo/history tools, four project/file tools) push past the comfortable 3-15 range and make the surface harder to hold in mind.

    Completeness4/5

    Coverage is strong: pattern creation, geometry readback, editing, copying and deletion, sewing, simulation, screenshots, fabric and colorway management, project/file lifecycle, export, and history, plus clo_execute_python and clo_search_api as an escape hatch. Minor gaps remain, e.g. no way to remove or inspect an individual seam without deleting a whole pattern piece, and avatar management is only reachable indirectly through clo_open_file.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      B
      quality
      D
      maintenance
      Enables AI-assisted garment design by letting Claude (or any MCP host) drive CLO3D — import projects, dress avatars, assign fabrics, simulate cloth, render, and export, all from a chat.
      14
      5
      MIT
    • A
      license
      C
      quality
      C
      maintenance
      Enables an AI assistant to interact with CLO3D projects, including inspecting scenes, editing patterns, sewing, changing fabrics, simulating, taking snapshots, and saving checkpoints.
      48
      1
      MIT
    • A
      license
      B
      quality
      B
      maintenance
      Enables controlling CLO3D from any MCP client to inspect projects, create and edit patterns, manage fabrics and colorways, run simulations, and export models through chat.
      104
      2
      MIT