Skip to main content
Glama

store_design

DestructiveIdempotent

Saves a named boat design spec on the server, replacing any existing design with that name, so later edits need only changes; returns the stored file path.

Instructions

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.

Input Schema

NameRequiredDescriptionDefault
nameYesName to store the spec under (letters, digits, spaces, _ - ( ), at most 64); replaces any stored design of that name.
specNoHull spec, partial or full (fields: hull_design_guide topic=spec); merged over preset or design. Lengths in metres.
patchNoJSON-Patch ops applied last, e.g. [{"op": "replace", "path": "/superstructure/bridge/height", "value": 2.5}]; list items can be named instead of indexed.
designNoStored design to start from instead of a preset; names from list_designs.
presetNoBuilt-in hull preset to start from, e.g. 'runabout'; names from list_hull_presets.
spec_pathNoPath to a .json file holding a spec or a stored design, read before spec and patch.

Output Schema

NameRequiredDescriptionDefault
resultYes

Schema Changelog

Changes observed during successful MCP inspections.

  1. Changed6 schema fields changedv0.2.0
    • addedInput schema / properties / design / description
      Added value: +"Stored design to start from instead of a preset; names from list_designs."
    • addedInput schema / properties / name / description
      Added value: +"Name to store the spec under (letters, digits, spaces, _ - ( ), at most 64); replaces any stored design of that name."
    • addedInput schema / properties / patch / description
      Added value: +"JSON-Patch ops applied last, e.g. [{\"op\": \"replace\", \"path\": \"/superstructure/bridge/height\", \"value\": 2.5}]; list items can be named instead of indexed."
    • addedInput schema / properties / preset / description
      Added value: +"Built-in hull preset to start from, e.g. 'runabout'; names from list_hull_presets."
    • addedInput schema / properties / spec / description
      Added value: +"Hull spec, partial or full (fields: hull_design_guide topic=spec); merged over preset or design. Lengths in metres."
    • addedInput schema / properties / spec_path / description
      Added value: +"Path to a .json file holding a spec or a stored design, read before spec and patch."
  2. First observedv0.1.0

TDQS

A4.9/5.0
Behavior5/5

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

Although annotations already declare destructive and idempotent behavior, the description adds substantive context: it replaces any stored design of that name, design=X copies spec plus parts/wires/pipes, undo history is not copied, and stored files are re-read on every call. These details materially affect how an agent should use the tool.

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

Conciseness5/5

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

The description is front-loaded with the core purpose and a concrete usage loop, then adds only operationally relevant details about replacement, copying, persistence, and return value. The length is justified by the mutation and cross-tool workflow being described.

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

Completeness5/5

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

For a six-parameter mutation tool with an output schema, the description covers the important workflow, replacement semantics, copied state, persistence behavior, and return value. An agent has enough information to invoke it correctly without needing to infer hidden behavior.

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

Parameters4/5

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

Schema coverage is 100%, so the schema already documents all six parameters well. The description still adds meaning beyond the schema by explaining that design=X copies the full draft state including edit_parts changes and connections, and that patch can invalidate parts requiring reconnection.

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

Purpose5/5

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

The description states a specific verb and resource: keep/store a design spec on the server without writing a vehicle. It clearly distinguishes the tool from preview_hull, save_hull, load_design, and list_designs through the described typical loop and replacement behavior.

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

Usage Guidelines5/5

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

It gives explicit usage guidance: call store_design with a spec once, use preview_hull to try changes, then store_design with a patch to keep them, and use save_hull when ready to write the vehicle. It also names related tools such as list_designs and edit_parts, so alternatives and sequencing are clear.

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