Skip to main content
Glama

Stormworks MCP

Describe a vehicle to your AI assistant. Load it at a workbench in Stormworks: Build and Rescue.

Latest release Downloads GitHub stars MCP server Made for Stormworks

Download for Windows

Install guide · Building walkthrough · Example prompts · What is verified in game

A 32 m coast guard cutter built with the hull generator: white hull with a red and navy bow flash and hull number 47, a two-level deckhouse and bridge, a lattice mast with a radar dome, railings and a painted helideck aft

Stormworks MCP is a local MCP server for Claude Desktop, the ChatGPT / Codex Windows app and other MCP clients. It gives the assistant tools to shape boat hulls, lay out rooms and engine rooms, place any part installed in your game, wire and plumb them, and find faults. The assistant looks at a render after every change, fixes what is off, and saves the result to your Stormworks vehicles folder.

Everything runs on your PC. Part definitions are read from your own game install, and game files are never changed.

How it works

  1. Describe it. "A 30 m coast guard cutter with a helideck aft", "a four-seat 4x4", "a six-cylinder boxer engine". Rough ideas are fine; the assistant asks about size and which workbench you build at.

  2. The assistant builds and checks it. It works in stages, renders each one, compares the picture with your request and fixes what is wrong. You see the previews too.

  3. Load it in game. The vehicle is saved with a Load-menu thumbnail. Open a workbench, press Load and pick it.

Every image on this page is a render of something the server built.

Related MCP server: Minecraft Builder MCP Server

What you can build

Boats and ships

Start from a hull archetype (runabout, rowboat, fishing trawler, tugboat, motor yacht, landing craft, lifeboat, patrol boat, catamaran, barge) or describe a hull from scratch: length, beam, depth, bow shape, rake, flare, deadrise, sheer, bulbous bow, skegs, and one to three hulls. Superstructure is built from boxes, cylinders, domes, spheres and lattice masts that can be stacked, mirrored, repeated, raked and rotated.

Nine hull presets rendered from above: runabout, fishing trawler, tugboat, motor yacht, patrol boat, catamaran, lifeboat, landing craft and barge

Railings, mooring points and ballast are added the way experienced builders place them, and every build reports its estimated waterline, trim and stability. Set a workbench size and the summary tells you whether the design fits; enter a real ship's dimensions with a scale such as 1:4, or let it scale the design to fill your workbench.

Hulls are plain blocks by default. Optional smoothing skins them with the game's wedge and pyramid pieces; it is still being refined, so check the preview before you save (hull smoothing).

Paint and liveries

Paint is per face, like a hand-built ship. Pick a named livery (navy, coast guard, workboat, research, yacht, dazzle or splinter camouflage) or design your own with hull numbers, bow flashes, stripes, hazard markings, panels, deck markings and camouflage.

The same cutter in six liveries: navy, coast guard, workboat, research, yacht and dazzle

Interiors and engine rooms

Add decks, bulkheads and rooms. The assistant gets a centreline section and a labelled plan of every level, with each room's size, headroom and doors. Doors and hatch-and-ladder assemblies are real game parts, fitted only where the whole part fits; a request that cannot fit leaves the wall sealed instead of cutting a hole.

Interior of the patrol boat preset: a section down the centreline with labelled rooms, and plans of the lower deck and the main deck

The powertrain stage puts a diesel engine low in the hull with its radiator and fuel tank, routes the pipes, and sets the propeller and rudder into the transom. Air comes in through a deck port and the exhaust leaves through the transom. Exposed pipes are colour-coded by what they carry.

Cutaway of a fishing trawler's engine room: the diesel engine, radiator, black exhaust pipes running aft to the transom outlets, the orange propeller shaft, blue coolant lines and the air intake grate on the deck

Cars, aircraft and anything else

Boats are one starting point. The assistant can also start from an empty draft, a land preset (a bare chassis, a buggy or a connected four-seat 4x4) or a copy of one of your own vehicles, and place any part installed in your game. Saved vehicles, or a box cut out of one, can be reused inside another as a prefab. Hinged and pivoting sections are separate bodies that can each be shown and edited.

The Humvee-shaped 4x4 preset: sand-coloured body with a sloped hood, recessed grille, headlights, raked windscreen and open door bays

Modular engines of any size are assembled from the game's own coupled parts: in-line, boxer or compact ring layouts with manifolds, starters, alternators, flywheel and clutch, and a list of every connection point to pipe and wire.

Two engines built by the server: a 3x3 boxer with six cylinders and a flywheel, and a compact 1x1 ring with eight cylinders

Wiring, fault finding and repair

The assistant connects signal and electric wires between part ports, routes pipes (exposed or inside blocks), and applies ready-made control set-ups for engine start, clutch, brakes and lights. A preflight check follows fuel, air, exhaust, cooling, the driveline, electric power and controls, and a repair plan turns each fault into a fix you can preview before it is applied. Other checks trace each compartment for leaks and estimate mass, flotation, thrust and lift.

Diagnostic overlay on the 4x4: the front-left wheel with a miswired steering input in red, steering arrows for each wheel in blue, and the proposed repair wire in green

Before you test, the assistant can export a separate copy with an in-game checklist tied to that exact file. See diagnose, repair and verify.

Checking its own work

Every change comes back as a picture: a 3/4 view from above and below plus front, side and top views with metre rulers. The assistant can also point a camera at any detail, hide the bodywork to look at the parts inside, or open the vehicle in an interactive 3D viewer in your browser. Edits go in batches that can be previewed first and undone afterwards.

The standard preview: 3/4 views from above and below, and front, side and top views with 1 m grids, of the coast guard cutter

Install

You need Windows 10 or 11, Stormworks installed through Steam, and an MCP client on the same PC.

  1. Close your AI client.

  2. Download the installer (-setup.exe) from the latest release and run it. It can add itself to Claude Desktop and the ChatGPT / Codex app for you.

  3. Open your AI client. It starts Stormworks MCP by itself in the background; there is no window to keep open.

The install guide covers the portable zip, running from source, setting up other clients by hand, upgrading, troubleshooting and configuration.

Your first boat

  1. Start a new chat and ask:

    Design me a chunky fishing boat for a small workbench. Show me a preview, then save it.

  2. Look at the previews as they come in and ask for changes: "taller wheelhouse", "make it navy grey", "add an engine room".

  3. In Stormworks, open a workbench, press Load and pick the name the assistant gave it.

Then check it against the in-game checklist. The building walkthrough covers stages, units and exact edits.

Example prompts

Boats

  • "Give me three different 10 m rescue boat hulls and show them side by side."

  • "Take the tugboat preset but make it longer and sleeker, like a pilot boat."

  • "Add an engine room aft, crew quarters amidships and a bridge, then show me the deck plans."

  • "Build a 1:4 scale model of a 110 m destroyer that fits my workbench."

  • "Paint it in the coast guard livery with hull number 47."

Other vehicles and parts

  • "Build the 4x4 preset, then show me the equipment with the bodywork hidden."

  • "Make a six-cylinder 3x3 boxer engine with a flywheel and two alternators."

  • "Turn the engine bay of my 'Old Trawler' into a prefab and drop it into this new hull."

  • "Estimate how my plane's lift compares to its weight."

Checking and fixing

  • "Run preflight on my 4x4 and preview the repairs before applying any."

  • "Check whether the engine room is watertight."

  • "Export a test copy and give me the in-game checklist."

  • "Import my 'Old Trawler' into a draft, repaint the bridge and save it as a new vehicle."

Good to know

  • The game is the only real test. The server writes files without running Stormworks. In-game testing tracks which features have been checked in game; load what you build and tell the assistant what you see.

  • Nothing is simulated. Preflight checks that the right parts are present and connected; physics numbers are estimates. Driving, flying and floating are decided in game.

  • Your vehicles are safe. Saving never overwrites a vehicle the server did not create. Imported vehicles are copied into a draft, and the original file is left alone.

  • Very large ships are fine to design, but the game spawns at most 131,072 parts. The build summary shows the part count against that limit.

  • The 3D viewer loads three.js from a CDN, so it needs an internet connection.

Documentation

Guide

Read it to

Install and set up

Install, connect a client, troubleshoot and configure.

Building walkthrough

Make a first build, keep units straight, edit exactly and diagnose a result.

Building any vehicle

Build from an empty draft: parts, connections, modular engines, prefabs, bodies and physics.

Staged builder

Build a boat in stages: components, access, propulsion, engine rooms, seals and tanks.

Land vehicles

Use the land presets, the chassis spec, parts, connections and preflight.

Diagnose, repair and verify

Repair faults, apply control set-ups and record in-game tests.

Hull smoothing

Choose slope pieces and check hull depth.

In-game testing

Check a vehicle in game and see what is verified.

Vehicle file format

Read or write Stormworks vehicle XML from your own tools.

Releases

Verify a download or build the Windows app yourself.

Development

Run the tests, regenerate these images and find your way around the code.

Contributing

Issues and pull requests are welcome. Changes must pass uv run pytest and uv run ruff check .; changes to geometry also need a rendered review and an in-game check. See development.

License

MIT. This is an unofficial fan project, not affiliated with or endorsed by Geometa, the developer of Stormworks. It modifies no game files and ships no game assets; part definitions are read from your own install at runtime.

Available Tools

49 tools
analyze_hullA
Read-onlyIdempotent

Measure actual hull material, floor gaps and partial-face seams at z stations: keel, walking floor and rim separately, since a part's footprint is not its solid material. Use it before saving to check depth and floor height, or to study a saved hull. Procedural reports use the fixed build frame and include floor height above keel and drop from the rim; saved vehicles use their own body-local frame, so pick body_id when the largest body is not the hull. Read-only geometry, not a seal test (use check_seal).

Inputs: x, name, spec, patch, +5 more. Returns: object

analyze_land_vehicleA
Read-onlyIdempotent

Measure a saved vehicle or a land draft for land building: body-local axles, wheelbase, mounts, light axes, controls and equipment, one section per call with paging. Use it on references from find_land_vehicles or on your own draft before editing; general part audits of boats use analyze_vehicle. Axle span measures mounting origins, not tyre-centre track; multi-body vehicles stay separate; suspension, steering sweep and mesh fit still need game checks. Read-only.

Inputs: name, limit, design, offset, +6 more. Returns: object

analyze_vehicleA
Read-onlyIdempotent

Audit how a saved vehicle is built: parts, logic links, controllers, bodies, placement issues such as rudder mounting and motion, connection candidates and open transmission ports, one section per call with paging. Use it to learn from the player's vehicles or to debug a save. Wheel layouts use analyze_land_vehicle, and hull material and floor gaps use analyze_hull. Handles multi-body vehicles. Read-only; findings are observations, not game verification.

Inputs: name (required), limit, offset, search, +2 more. Returns: object

apply_vehicle_assemblyA
Destructive

Configure and wire a reusable control set-up (starter and idle, clutch, brake/reverse or lights) using explicit current part ids, instead of wiring each link with edit_connections. Existing drivers of the target inputs are replaced atomically. Clutch needs its own gate, separate from the idle throttle gate. Starter is manual/hold; idle is open-loop, and reverse must be selected while stopped. engine_start_idle takes one engine id or a list (twins share the throttle gate and starter). Returns the operations and a compact preflight (detail=true for all of it, preview=true for the diagnostic image); commit=true creates one undo step. Tune behaviour in game.

Inputs: design (required), assembly (required), bindings (required), revision (required), +4 more. Returns: assembly, bindings, revision, committed, +4 more

check_sealA
Read-onlyIdempotent

Test whether a draft is watertight by tracing from interior points to the outside: sealed, leaking or indeterminate per compartment. Returns an image with any escape path highlighted and a report of connected compartments. Use it after edits that touch the hull or doors. Unsupported sealing geometry nearby prevents a confident pass. Read-only.

Inputs: design (required), seeds, door_state.

create_land_vehicleA

Create a new land vehicle draft and return its preview image, notes and revision. The default utility buggy has bodywork, four suspension wheels, saddle, premade fuel tanks, engine, battery, radiator and lights; humvee_4x4 has four seats, open custom-door bays, compact glass and enclosed chassis pipework; utility_4x4 keeps the older sliding-door layout. Read land_vehicle_guide first. Writes only a stored draft, never a game file, and refuses an existing name. Then complete it with query_parts/edit_parts and the connection tools, check it with preflight_vehicle, and save it with save_vehicle.

Inputs: design (required), spec.

deck_profileA
Read-onlyIdempotent

Tabulate the deck at stations from the transom: deck height above the keel, the y a superstructure box gets when y is left out, and the deck half-beam. Use it to place turrets and deckhouses on a sheered deck instead of guessing heights. Lengths are in spec units (real-world metres when the spec has a scale). Read-only; returns a text table.

Inputs: spec, step, patch, design, +2 more. Returns: result

edit_connectionsA
Destructive

Add or remove typed control and electrical wires in a draft. Uses the query_connections revision. Ops: {op:'connect',from:{part_id,port},to:{part_id,port}} or {op:'disconnect',link_id}. Signal outputs connect to inputs; electricity is bidirectional. One driver per signal input. Pipes and shafts use route_connections; whole starter, clutch, brake or light set-ups use apply_vehicle_assembly. Original XML and settings stay lossless. Returns the wires added and removed, warnings and the new revision; preview=true adds the image and full notes. commit=true keeps one undo step.

Inputs: design (required), revision (required), operations (required), commit, +1 more.

edit_partsA
Destructive

Add, remove, move, rotate, paint or copy parts in a draft as one atomic batch. Pass the revision from query_parts. Ops: add(part/parts), fill(bounds,color), remove/replace/move/rotate/paint/copy/mirror/repeat. Selection ops need select={ids/bounds/name/definition}. move/copy/repeat use delta in blocks; repeat count is additional copies; rotate uses a local-to-world matrix or r string and pivot; mirror uses axis and plane. replace needs part; paint needs color. Added parts use definition, position in blocks, rotation, optional mirror (1=x, 2=y, 4=z), color, name and scalar settings. Placement rotation accepts an effective mirrored matrix; use that or proper rotation plus mirror. Prebuilt engines default to max_force_scale=1 (100%). Returns what changed (added parts with their new ids, such as edit:0:0, next to the names you gave), warnings and the new revision; preview=true adds the image and full notes. commit=true keeps one undo step (undo_edits). Wires and pipes use edit_connections and route_connections.

Inputs: design (required), revision (required), operations (required), commit, +1 more.

find_land_vehiclesA
Read-onlyIdempotent

Scan the player's saved vehicles, or installed Workshop items, for wheel or track layouts to use as land-build references, including unnamed experiments, with paging. Counts vehicle body components only, not controller internals; wheeled boats or aircraft can match, so a hit says nothing about a vehicle's purpose or quality. Follow up on a match with analyze_land_vehicle; list_game_vehicles only lists names. Read-only.

Inputs: kind, limit, offset, search, +1 more. Returns: object

get_calibration_observationsA
Read-onlyIdempotent

Read the player's recorded in-game checks for one part: the latest result per test case and check, the number of stale reports (the definition or test vehicle changed since), and checks with contradictory results. Use it before relying on an orientation or mounting rule for that part. It reports evidence and runs no test. Read-only; returns no checks when nothing was recorded.

Inputs: definition (required). Returns: object

get_hull_specA
Read-onlyIdempotent

Return the fully resolved hull spec, every parameter with its value, for a preset or for the defaults. Use it to see what a preset sets or as a starting spec to copy and change; hull_design_guide(topic="spec") explains each field. Read-only.

Inputs: preset. Returns: object

get_part_definitionA
Read-onlyIdempotent

Return one installed part's definition: footprint voxels, attachment and sealing surfaces, logic nodes, settings, mass, seal coverage, and whether new placement is allowed (with the reason when it is not). Use it after search_parts to check how a part mounts, connects or seals; get_part_orientation solves its rotation. Read-only; fails when the definition is not installed.

Inputs: definition (required). Returns: object

get_part_orientationA
Read-onlyIdempotent

Explain a part's local mounting, motion and function axes and solve the rotation that points them in the requested world directions. Example Fin Rudder targets: mount_normal=[0,0,1], span_axis=[0,1,0]. Road wheel targets should include axle_axis, wheel_reference_up and wheel_forward; right placements can require mirror. Returns the effective rotation plus the proper r and mirror for edit_parts or XML. Read-only; arrow signs still need checking in game.

Inputs: definition (required), targets. Returns: object

get_runtime_statusA
Read-onlyIdempotent

Report the server version and the paths it uses: Stormworks vehicles folder, game part definitions, stored designs, build cache, and the tool timeout, with notes on anything missing. Use it when a tool cannot find the game, its parts or the player's vehicles. Read-only; it never creates folders.

Inputs: no named parameters. Returns: object

get_vehicle_validationA
Read-onlyIdempotent

Read a validation run: the checklist with any recorded results and evidence, plus export_matches and draft_matches, which say whether the exported file and the draft are still the ones tested. Read-only; fails when the run id is unknown.

Inputs: run_id (required). Returns: object

hull_design_guideA
Read-onlyIdempotent

Return the boat design guide as Markdown: workflow, units, every spec field, style rules and lessons from in-game testing. Read topic="workflow" before designing a boat, then fetch focused topics as needed instead of resending the full guide. Road and land vehicles have their own guide (land_vehicle_guide). Read-only.

Inputs: topic. Returns: result

import_vehicleA

Copy an existing single-body vehicle (data version 3) into a new editable draft; the source file is never changed. Use it to modify a vehicle the player already has, then query_parts/edit_parts, preview_vehicle, and save_vehicle under a different name. Configured and wired parts are protected. Fails when the draft name exists, the vehicle has several bodies or it uses an older data version. Returns the part count.

Inputs: name (required), design (required), source. Returns: result

inspect_viewA
Read-onlyIdempotent

Render one large view of a hull design or saved vehicle from any angle, like a camera you can point, to check details the fixed previews hide. Returns the image and a caption; with highlight, the box's position in spec units and as game-metre heights above the keel. Views at pitch 0 or +-90 get metre rulers in spec units (z from the transom, y from the keel, x from the centreline). Use preview_hull for the standard set of views. Read-only.

Inputs: yaw, name, spec, zoom, +10 more.

land_vehicle_guideA
Read-onlyIdempotent

Return the road and land vehicle guide as Markdown: workflow, installed parts, chassis spec, units, layout limits and the checks to do in game. Read it before create_land_vehicle or any land work; boats use hull_design_guide instead. Read-only.

Inputs: no named parameters. Returns: result

list_designsA
Read-onlyIdempotent

List the names of drafts stored on this server, sorted: hull designs (store_design, save_hull), imported vehicles (import_vehicle) and land drafts (create_land_vehicle). Pass a name as design to other tools, or to load_design to read it. Vehicles in the game's folder are listed by list_game_vehicles instead. Read-only.

Inputs: no named parameters. Returns: result

list_game_vehiclesA
Read-onlyIdempotent

List the vehicle names in the player's Stormworks vehicles folder, sorted. Pass a name to preview_game_vehicle, inspect_view, analyze_vehicle or import_vehicle. Drafts stored on this server are listed by list_designs. Read-only; fails when the folder is missing (set SW_VEHICLES_DIR).

Inputs: search. Returns: result

list_hull_presetsA
Read-onlyIdempotent

List the built-in boat hull presets: name, one-line description, length x beam x depth in metres, and whether it has an interior. Pass a name as preset to preview_hull or save_hull, or to get_hull_spec to see every value it sets. Stored designs are listed by list_designs and the player's saved vehicles by list_game_vehicles. Read-only.

Inputs: no named parameters. Returns: result

list_vehicle_assembliesA
Read-onlyIdempotent

List the reusable control assemblies (engine start and idle, clutch engagement, brake/reverse, lighting) with the part ids each must be bound to and the logic gates it expects. Place any required gates with edit_parts, then bind the queried ids with apply_vehicle_assembly. Geometry is not preset-specific. Read-only.

Inputs: no named parameters. Returns: object

list_workbenchesA
Read-onlyIdempotent

List the workbench size keywords (S, M, L, XL, XXL, MAX) with each size in metres and the edit areas in the player's game, including workbench mods, that are at least that big. Ask the player which bench they will build at, then set it as bench in the spec; preview summaries then say whether the design fits and by how much it misses. Read-only.

Inputs: no named parameters. Returns: result

load_designA
Read-onlyIdempotent

Read a stored draft. A hull design returns its full spec; to change it, prefer design=name with patch=[...] in preview_hull or store_design over resending the spec. An imported or land draft returns its kind, source, current revision, coordinate frame and edit log; change those with query_parts and edit_parts, not a spec. Read-only; fails when no draft has that name.

Inputs: name (required). Returns: object

open_in_viewerA
Idempotent

Open a vehicle or design in the interactive 3D viewer in the player's web browser so they can orbit and inspect it themselves. You cannot see that window: use inspect_view or the preview tools to look yourself. Writes one temporary HTML page, replaced on each call, and changes nothing else. Uses installed component meshes with explicit fallbacks; articulated vehicles show the largest body alone unless body_id is given.

Inputs: name, spec, patch, design, +5 more. Returns: result

plan_vehicle_repairsA
Read-onlyIdempotent

Diagnose a draft's faults and test suggested edits, wires and pipes without changing it. Returns each finding's severity, affected ids, explanation, concrete operations, and whether it can be repaired automatically or needs a design choice. Pass the returned revision, plan_id and the ids of available findings to repair_vehicle. Read-only.

Inputs: design (required). Returns: plan_id, findings, revision, verification

preflight_vehicleA
Read-onlyIdempotent

Check that a draft's systems are connected: engine fuel/air/exhaust/radiator paths, driveline (to wheels, or straight to a propeller on boats: no clutch or gearbox needed), electrical power and controls. By default lists only the faults, each once; detail=true adds every passing check, configuration_checks (explicit engine power), gearbox_configuration_checks, wheel_direction_checks and repair operations. A missing check's detail names what it expected and what the port does reach. Run it after wiring or routing and before saving; plan_vehicle_repairs turns its findings into fixes. Read-only; connected geometry still needs testing in game.

Inputs: design (required), detail. Returns: checks, issues, status, findings, +11 more

prepare_vehicle_validationA
Destructive

Export a draft as a separate test vehicle in the game folder and open a validation run: a seven-check in-game checklist tied to the file's exact SHA-256 and the draft revision. Use it when a draft is ready for the player to test; record their results with record_vehicle_validation and review them with get_vehicle_validation. Refuses vehicles this tool did not write and replaces its own only with overwrite=true. Checks start pending; connected geometry never counts as game evidence.

Inputs: name (required), design (required), overwrite. Returns: checks, design, run_id, status, +9 more

preview_game_vehicleA
Read-onlyIdempotent

Render a vehicle from the player's vehicles folder or an installed Workshop item and return the image plus a size and part summary, e.g. to study the player's existing boats. Uses installed component meshes, reporting any footprint fallbacks. Articulated vehicles show the largest body alone unless body_id is given. inspect_view points a camera at one detail; drafts use preview_vehicle. Read-only.

Inputs: name (required), source, body_id, renderer.

preview_hullA
Read-onlyIdempotent

Build a hull and return a preview image (3/4 views from above and below, front, side, top) plus a text summary: size, part counts, deck heights, flotation estimate, bench fit and warnings. This is the design loop: preview, compare the image with the player's brief, adjust, repeat, then save_hull. Use inspect_view for one large close-up from any angle and preview_interior for rooms. Nothing is written. Spec sources apply in order: preset or design, spec_path, spec, patch.

Inputs: spec, patch, design, preset, +2 more.

preview_interiorA
Read-onlyIdempotent

Render an interior cutaway: a centreline section plus a labelled deck plan for every room level, and a per-room report (clear size, floor width, doors with sill heights and floor steps, engines, warnings). Use it after adding interior to a spec (hull_design_guide topic=interior); preview_hull shows the outside. Floors above the main deck are cropped to their rooms. Nothing is written.

Inputs: spec, patch, design, preset, +1 more.

preview_vehicleA
Read-onlyIdempotent

Render a draft (imported, land or edited hull) with installed component meshes and return the image plus notes. yaw/pitch/zoom/focus give a close-up; layer=components hides bodywork to inspect seats, tanks and powertrain. Hull specs use preview_hull and vehicles in the game folder use preview_game_vehicle. Paint and wheel poses are approximate; the image is not an in-game screenshot. Read-only.

Inputs: design (required), yaw, zoom, focus, +4 more.

preview_vehicle_diagnosticsA
Read-onlyIdempotent

Render a draft with its preflight faults drawn over it: red faulty parts, amber blocked exits, blue wheel and steering arrows. Returns the image and the preflight report. Use it to see where preflight_vehicle's findings are; open_in_viewer(design=..., diagnostics=true) gives the player an interactive version. Coordinates are draft blocks. Read-only.

Inputs: design (required), yaw, layer, pitch. Returns: overlay, revision, preflight

query_connectionsA
Read-onlyIdempotent

List a draft's connection points and links: each component's logic and electric node indices and its pipe/transmission surface indices, existing wires and routes with stable link ids, and the draft revision. Call it before edit_connections, route_connections or apply_vehicle_assembly. Wire endpoints are {part_id,port}; pipe endpoints are {part_id,surface_index}. Coordinates are uncentred integer blocks. Read-only, paged by component; query_parts lists geometry instead.

Inputs: design (required), limit, offset. Returns: object

query_partsA
Read-onlyIdempotent

List a draft's parts and its current revision for exact editing. Rows include id, definition, position, scalar settings, proper rotation plus a local mirror bitmask, and the effective transform matrix. Coordinates are integer blocks (0.25 m): the uncentred build frame for generated hulls and land drafts, the original body-local frame for imports. Call it before edit_parts and pass its revision. A selection that cuts through a multi-voxel part is rejected; select its id instead. Read-only.

Inputs: design (required), limit, offset, select. Returns: object

record_vehicle_validationA
Destructive

Record what the player observed in game for a validation run. Only human observations belong here, never preflight output. Each observation replaces any earlier result for the same check. Refuses a changed export, a mismatched hash or a different game version. The run passes only when all seven checks pass with evidence.

Inputs: run_id (required), tester (required), game_version (required), observations (required), +1 more. Returns: checks, design, run_id, status, +9 more

repair_vehicleA
Destructive

Apply chosen fixes from plan_vehicle_repairs to a draft; previews by default, with overlays and a before/after preflight. commit=true applies the batch as one undo step; rerun preflight_vehicle afterwards. Stale revisions or plans and conflicting repairs are rejected. Manual findings need a design choice and are never applied here.

Inputs: design (required), plan_id (required), revision (required), finding_ids (required), +1 more. Returns: after, before, revision, committed, +3 more

route_connectionsA
Destructive

Lay physical pipes between transmission faces in a draft, preserving access and structure. Wires use edit_connections instead. Each route: {from:{part_id,surface_index},to:{part_id,surface_index},bounds?:[[lo],[hi]], waypoints?:[[x,y,z],...],name?:str,pipe_style?:auto|exposed|enclosed,through_blocks?:[part_id,...], color?:RRGGBB}. Bounds/waypoints use integer blocks. Routes minimize length, then bends. Default auto uses enclosed pipes for explicitly selected through_blocks; other cells use exposed pipes. through_blocks replaces only selected unconfigured/unlinked 01_block parts, retaining paint. Exposed pipes are colour-coded by contents (ISO 14726: fuel brown, cooling/fresh water blue, sea water green, exhaust black, air maroon, oil orange; shafts orange); color overrides it. Enclosed pipes keep the colour of the hull around them. All selected blocks must lie on the route (use waypoints if needed); removal restores them. Other structure and access are preserved; routes never join unrelated pipe networks. Clutch/gearbox ports may use several routes; create an explicit T-piece for a branch. Remove an added route with {op:'remove',route_id} from query_connections, then reroute. Returns the pipes added per route, warnings and the new revision; preview=true adds the image and full notes. commit=true keeps one undo step.

Inputs: design (required), routes (required), revision (required), commit, +1 more.

save_hullA
Destructive

Write a hull into the Stormworks vehicles folder as .xml with its Load-menu thumbnail, and store the spec as a design of the same name. Use it once the preview is approved, e.g. save_hull(name="Iowa", design="Iowa"); drafts edited part by part (imports, land vehicles) use save_vehicle. Refuses a name already used by a vehicle this tool did not write, and replaces its own earlier save only with overwrite=true. Returns the file path, part count and summary; the player loads it from a workbench's Load menu.

Inputs: name (required), spec, patch, design, +3 more. Returns: result

save_vehicleA
Destructive

Write a stored draft into the Stormworks vehicles folder as .xml with its Load-menu thumbnail. Use it for drafts edited part by part (imports, land vehicles, edited hulls); save_hull is the shortcut for a hull spec. Refuses a name used by a vehicle this tool did not write and the imported original, even with overwrite=true; replaces its own earlier save only with overwrite=true. Returns the file path, part count and notes.

Inputs: name (required), design (required), overwrite. Returns: result

score_vehicleA
Read-onlyIdempotent

Compare a saved vehicle (name), a draft or stored design, or a hull spec/preset with a reference set from study_references. Each construction metric is checked against the min-max of references of the same kind, with a hint where it falls outside. A miss says where to look, not that the vehicle is broken: references differ in size and purpose. Read-only.

Inputs: reference_set (required), kind, name, spec, +4 more. Returns: object

search_land_partsA
Read-onlyIdempotent

List installed components useful for land builds, by family, with footprints and their actual connection ports, with paging. Use it to choose parts for a land draft. search_parts covers the whole catalogue without families; get_part_definition and get_part_orientation give one part's detail. Read-only.

Inputs: limit, offset, search, category. Returns: object

search_partsA
Read-onlyIdempotent

Search the installed Stormworks part catalogue by definition id or display name. Each row gives the id, display name, size in blocks and metres, and mass, with the total and next_offset for paging. Use it to find a definition id, then get_part_definition for surfaces and sealing or get_part_orientation for mounting axes. search_land_parts groups land-build families; query_parts lists the parts inside a draft. Read-only.

Inputs: limit, offset, search. Returns: object

store_designA
DestructiveIdempotent

Keep a design spec on the server without writing a vehicle, so later calls can send only changes. Typical loop: store_design("Iowa", spec=...) once, then preview_hull(design="Iowa", patch=[...]) to try a change and store_design("Iowa", design="Iowa", patch=[...]) to keep it. Replaces any stored design of that name; save_hull(name, design=name) writes the vehicle when ready. design=X copies all of draft X: its spec, the parts added with edit_parts, and its wires and pipes (a patch that removes a part they use makes later calls ask you to reconnect it). Undo history is not copied. Stored designs are plain JSON files that every call re-reads, so editing one on disk takes effect at once. Returns the stored file's path.

Inputs: name (required), spec, patch, design, +2 more. Returns: result

study_referencesA
DestructiveIdempotent

Measure how vehicles the player rates are built: slope piece sizes, pyramid/inverse pairing, ballast, sub-bodies, detail parts, paint and logic. kind (boat/land/other) is detected from road wheels and marine propulsion unless given; mark hovercraft, aircraft and unusual builds "other" so they don't widen the boat range. Returns per-vehicle metrics and the min-max range per kind. Writes nothing unless save_as is given. Measurements describe habits, not quality.

Inputs: references (required), save_as. Returns: object

suggest_hull_blocksA
Read-onlyIdempotent

Rank the game's slope block families (wedges, pyramids and inverse pyramids by slope ratio) by how closely they match a surface's outward normal, with the rules for choosing between them. Use it when placing hull slopes by hand. The angle alone cannot choose pyramid vs inverse, the position, or a watertight joint: check those with inspect_view and check_seal. Read-only.

Inputs: normal (required), limit. Returns: object

undo_editsA
Destructive

Revert a draft to before its last committed batch from edit_parts, edit_connections, route_connections, repair_vehicle or apply_vehicle_assembly. Keeps up to ten batches; there is no redo. Fails when the revision is stale or nothing is left to undo. Returns the new revision and the number of undo steps remaining.

Inputs: design (required), revision (required). Returns: object

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    A3.9/5.0

    Scored across 49 tools

    Disambiguation3/5

    The descriptions go to great lengths to cross-reference each other (e.g. 'boats use hull_design_guide instead', 'wires use edit_connections'), which helps, but the surface has many near-siblings: preview_hull vs preview_vehicle vs preview_game_vehicle vs preview_interior vs preview_vehicle_diagnostics, and analyze_vehicle vs analyze_land_vehicle vs analyze_hull vs study_references. An agent must carefully parse long prose to pick correctly, and similar tool names invite misselection.

    Naming Consistency4/5

    Almost all tools use a predictable verb_noun snake_case pattern (list_, get_, preview_, analyze_, search_, save_, edit_, query_, apply_, prepare_, record_, plan_, repair_, check_, open_, import_, find_, score_, study_, suggest_, undo_). A few noun-first outliers (hull_design_guide, land_vehicle_guide, deck_profile) are minor deviations but still readable.

    Tool Count2/5

    At 49 tools the surface is heavy even for a complex CAD-like domain, with many specialized variants (separate preview, analyze, guide, and save tools per resource type). Consolidation into parameterized tools would reduce the burden on an agent navigating this set.

    Completeness4/5

    The lifecycle is well covered: design from presets/specs, edit parts, wire/pipes, preflight and repair planning, validation runs, save, and analysis/scoring. Minor gaps exist (e.g. no delete/rename of stored drafts or saved vehicles), but agents can work around them.

    Maintenance

    ActivityNo data
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • F
      license
      Not graded
      quality
      D
      maintenance
      Enables Claude to create and manipulate SolidWorks CAD models through natural language commands, automating part creation, sketching, and extrusion.
      10
      -
    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables Claude to control SolidWorks through natural language, supporting part and assembly creation, sketches, advanced features, dimension editing, selection inspection, screenshots, and rebuilds.
      MIT
    • A
      license
      A
      quality
      C
      maintenance
      Enables Claude to model 3D-printable parts by running Python scripts in a headless FreeCAD instance and exporting STL/3MF/STEP files. It also lets Claude visually inspect renders, check mesh integrity and overhang printability, measure volume and estimated mass, and open results in a slicer before printing.
      10
      MIT