Stormworks MCP
A local MCP server that lets an AI assistant design, build, check and save Stormworks vehicles — boats, land vehicles and modular engines — as game-ready XML files you load at a workbench.
Design hulls from 10+ presets (runabout, trawler, tugboat, catamaran, barge…) or a full spec: length, beam, bow shape, flare, deadrise, multiple hulls, superstructure, railings, ballast, and optional wedge/pyramid hull smoothing.
Preview as images — standard 3/4, front, side and top views with metre rulers, close-up
inspect_view, interior cutaways and deck plans, and an interactive 3D browser viewer.Paint and livery per face: navy, coast guard, workboat, research, yacht, dazzle, camouflage, plus hull numbers and markings.
Build interiors and engine rooms: decks, bulkheads, rooms, doors, hatch-and-ladder assemblies, and a full powertrain (engine, radiator, fuel tank, pipes, propeller, rudder).
Make land vehicles from presets (utility buggy, Humvee 4x4, chassis) or by importing your own vehicles into editable drafts.
Assemble modular engines of any size: in-line, boxer or ring layouts with manifolds, flywheel, clutch and connection points.
Place and edit any installed part — search the part catalogue, check definitions and orientations, and add/move/rotate/paint/mirror/copy parts in atomic, undoable batches.
Wire and plumb: signal and electric wires between ports, routed pipes (exposed or through blocks, colour-coded by contents), and ready-made control set-ups for engine start, clutch, brakes and lights.
Fault-find and repair: preflight checks for fuel/air/exhaust/cooling/driveline/power/controls, diagnostic overlays, leak testing, and previewable repair plans.
Save and export to your Stormworks vehicles folder with Load-menu thumbnails, safely refusing to overwrite files it did not write.
Learn from references: analyse, measure and score saved or Workshop vehicles, and run hash-tracked in-game validation checklists.
Read built-in guides: hull design, land vehicles, staged building, vehicle file format and in-game testing.
Source code repository for the MCP server, hosted on GitHub.
Reads Stormworks: Build and Rescue game files through Steam libraries to locate part definitions, workbench locations, and workshop tile mods, and saves generated vehicle files into the Stormworks vehicles folder.
Renders 3D vehicle previews in a standalone browser viewer, letting users orbit, switch views, toggle outlines and a 1 m grid, and save screenshots.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Stormworks MCP Design me a chunky fishing boat for bench size S. Show me a preview, then save it."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Stormworks MCP
Describe a vehicle to your AI assistant. Load it at a workbench in Stormworks: Build and Rescue.
Install guide · Building walkthrough · Example prompts · What is verified in game

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
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.
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.
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.

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.

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.

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.

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.

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.

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.

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.

Install
You need Windows 10 or 11, Stormworks installed through Steam, and an MCP client on the same PC.
Close your AI client.
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.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
Start a new chat and ask:
Design me a chunky fishing boat for a small workbench. Show me a preview, then save it.
Look at the previews as they come in and ask for changes: "taller wheelhouse", "make it navy grey", "add an engine room".
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, connect a client, troubleshoot and configure. | |
Make a first build, keep units straight, edit exactly and diagnose a result. | |
Build from an empty draft: parts, connections, modular engines, prefabs, bodies and physics. | |
Build a boat in stages: components, access, propulsion, engine rooms, seals and tanks. | |
Use the land presets, the chassis spec, parts, connections and preflight. | |
Repair faults, apply control set-ups and record in-game tests. | |
Choose slope pieces and check hull depth. | |
Check a vehicle in game and see what is verified. | |
Read or write Stormworks vehicle XML from your own tools. | |
Verify a download or build the Windows app yourself. | |
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 toolsanalyze_hullARead-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_vehicleARead-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_vehicleARead-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_assemblyADestructive
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_sealARead-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_profileARead-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_connectionsADestructive
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_partsADestructive
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_vehiclesARead-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_observationsARead-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_specARead-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_definitionARead-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_orientationARead-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_statusARead-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_validationARead-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_guideARead-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_viewARead-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_guideARead-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_designsARead-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_vehiclesARead-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_presetsARead-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_assembliesARead-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_workbenchesARead-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_designARead-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_viewerAIdempotent
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_repairsARead-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_vehicleARead-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_validationADestructive
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_vehicleARead-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_hullARead-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_interiorARead-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_vehicleARead-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_diagnosticsARead-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_connectionsARead-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_partsARead-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_validationADestructive
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_vehicleADestructive
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_connectionsADestructive
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_hullADestructive
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_vehicleADestructive
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_vehicleARead-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_partsARead-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_partsARead-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_designADestructiveIdempotent
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_referencesADestructiveIdempotent
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_blocksARead-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_editsADestructive
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
Scored across 49 tools
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.
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.
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.
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
Related MCP Connectors
CAD in ChatGPT and Claude: editable parts, STEP/STL/drawings, in-chat 3D, automatic checks.
Generate and edit images and create short videos inside Claude. Prepaid credits, no subscription.
Turn Claude into a creative studio: DNA-locked characters, images, video, voiceover — 55 tools.
Your own Claude designs and codes Godot 4 games; each build is tested with real screenshots.
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceEnables Claude to create and manipulate SolidWorks CAD models through natural language commands, automating part creation, sketching, and extrusion.10-
- FlicenseNot gradedqualityDmaintenanceEnables Claude to generate Minecraft structures from natural language descriptions, creating .schem files for WorldEdit import.16-
- AlicenseNot gradedqualityBmaintenanceEnables Claude to control SolidWorks through natural language, supporting part and assembly creation, sketches, advanced features, dimension editing, selection inspection, screenshots, and rebuilds.MIT
- AlicenseAqualityCmaintenanceEnables 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.10MIT