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

No annotations are provided, so the description carries the full behavioral burden. 'Add' implies a model mutation, but the description does not disclose permissions, side effects, interaction with existing ports, or what the active project state must be. It adds only the microstrip-safety context, which is useful but far from sufficient for a mutation tool.

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

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

The description is a single front-loaded sentence with no filler. Although it is under-specified for the tool's complexity, that issue is captured in other dimensions; as a matter of conciseness and structure, it contains no wasted language.

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

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 no annotations and no schema parameter descriptions, the definition is far too thin. The presence of an output schema means return values need not be explained, but the agent still lacks critical context about prerequisites, parameter meaning, and side effects.

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

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

Schema description coverage is 0%, so the description must compensate for six undocumented parameters. It only hints at the impedance parameter via 'explicit reference impedance' and does not explain point1, point2 coordinate formats, port_number, label, or monitor. This leaves most parameter semantics unclear.

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

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

States a specific verb and resource: adding a discrete S-parameter port. It also adds a meaningful differentiator, 'explicit reference impedance (safe for microstrip feeds)', which helps distinguish it from a generic or waveguide-port tool. It does not explicitly name or compare against the sibling cst_add_waveguide_port_tool, so sibling differentiation is implied rather than stated.

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

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

The phrase 'safe for microstrip feeds' implies a use case and therefore some guidance. However, it gives no explicit when-to-use vs alternatives, no prerequisites, and no exclusion conditions. The agent must infer that this is the right port type for microstrip scenarios.

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

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

With no annotations provided, the description carries the full behavioral burden. It discloses that a monitor is added and lists monitor categories, but it omits whether the operation mutates project state, what permissions or open-project context are required, and whether it is reversible.

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

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

The description is a single concise sentence with the purpose front-loaded and no wasted words. It is appropriately sized, though its brevity contributes to the missing parameter and behavior details.

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

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

For a 6-parameter mutation tool with no annotations and 0% schema description coverage, the description is too sparse. The output schema means return values need not be described, but the description still leaves key invocation context and parameter semantics undocumented.

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

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

Schema description coverage is 0% and there are 6 parameters, so the description must compensate substantially. It hints at possible values for field_type ('far field, E/H field, power flow, current or loss'), but it says nothing about name, domain, frequency, plane_normal, or plane_position.

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

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

The description names a specific verb and resource ('Add a field monitor') and lists the supported monitor types. It is clear what the tool does, though it does not explicitly differentiate itself from sibling monitor-listing tools such as cst_list_monitors_tool.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives. It implies use when adding a monitor, but it never states prerequisites, when-not-to-use conditions, or related sibling tools.

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

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

No annotations are provided, so the description carries the full burden. It does not disclose that vba_code is likely executed, whether the operation is reversible, whether it mutates the project state, or what happens on invalid code — material traits for a write tool with a code parameter.

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

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

A single efficient sentence with the action front-loaded and the example list kept short. No wasted words, though it is arguably too terse for the risk profile of the operation.

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

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

An output schema exists, so return values need not be explained. However, for a mutation tool with a raw-code parameter and zero annotations, the description omits safety, side-effect, and parameter-format information that an agent needs to invoke it correctly.

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

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

Schema description coverage is 0%, so the description must compensate. 'One named block' loosely maps to 'title', but the required 'vba_code' parameter is never explained — no format, language, or expected content is given.

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

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

States a specific verb ('Append') and resource ('model history tree'), with parenthetical examples of block types. It is clear what the tool does, though it offers no differentiation from the many sibling *_tool entries that presumably also touch history or VBA.

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

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

No guidance on when to use this versus cst_run_vba_tool or cst_runtime_invoke_tool, no prerequisites, no mention of ordering constraints within the history tree. The agent must infer usage entirely from the name.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it only says it adds a port. It does not disclose permissions required, whether the port persists across solver runs, how it interacts with existing ports, or what 'on a plane' constrains. 'Add' at least signals a mutation, but the disclosure is minimal.

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

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

A single front-loaded sentence with no filler — structurally clean. It is concise rather than bloated; the weakness is under-specification, which is captured in the other dimensions rather than a conciseness failure.

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

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

For a 9-parameter mutation tool with zero annotation coverage and no parameter documentation, this description is far too thin. An agent cannot safely construct the required range/orientation/port_number arguments, and the presence of an output schema does not compensate for the missing input and behavioral context.

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

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

Schema description coverage is 0% across 9 parameters, and the description supplies no parameter meaning at all. Field names like 'xrange/yrange/zrange', 'orientation', 'on_boundary', 'reference_plane' and 'n_modes' are highly ambiguous (array vs. scalar ranges, orientation encoding, units) and remain completely unexplained.

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

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

States a specific verb (add) and resource (waveguide port) plus placement (on a plane of the calculation domain), which implicitly distinguishes it from sibling cst_add_discrete_port_tool. However, it never names that sibling or clarifies what makes a waveguide port different, so sibling differentiation is only implied.

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

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

There is no when-to-use guidance, no prerequisites (e.g., that a project must be open or that 'plane' refers to a boundary), and no mention of alternatives such as cst_add_discrete_port_tool. The agent must infer everything about context.

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

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

No annotations are provided, so the description must carry the full behavioral burden for a mutation tool. It says what action occurs but does not disclose side effects, whether an existing material assignment is overwritten, required permissions, or any failure behavior.

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

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

The description is a single front-loaded sentence with no wasted words, which is structurally efficient. It is arguably too terse for the operation's missing context, but the conciseness itself is strong.

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

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

Given a mutation tool with no annotations, 0% schema description coverage, and only basic required parameters, the description is substantially incomplete. The output schema covers return values, but missing prerequisites and side-effect details leave the agent under-informed.

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

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

Schema description coverage is 0% and neither parameter has a description. The prose names 'solid' and 'material' only in passing, adding no format, naming convention, or identification details beyond the schema's property names.

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

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

The description states a specific verb ('Assign') and resource ('existing material to a solid'), making the operation understandable without opening the schema. It also implicitly distinguishes itself from material creation or library loading by saying 'existing material,' though it does not explicitly name sibling tools.

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

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

No when-to-use, when-not-to-use, or alternative-tool guidance is provided. The description implies the basic operation but does not explain prerequisites such as whether the solid and material must already exist in the project.

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

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

With no annotations, the description carries the full behavioral burden but discloses almost nothing. It does not say whether the input solids are consumed/merged, whether the operation is reversible, or what permissions are required. The only behavioral hint is the verb 'Combine', which implies mutation but leaves consequences unspecified.

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

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

A single, front-loaded sentence with no filler; every word earns its place. It is efficient, though the terseness contributes to the gaps noted elsewhere.

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

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

For a 4-parameter mutation tool with no annotations and 0% schema description coverage, the description is under-specified. It omits what target/tool refer to, what the operation values mean relative to those inputs, and the effect on the source solids; an output schema exists, so return values are the one area it need not cover.

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

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

Schema coverage is 0% and no parameter has an enum, yet the description only partially compensates by naming the operation values (add/subtract/intersect/insert). The required 'target' and 'tool' parameters are entirely unexplained, and even the operation values are given without mapping to the schema field.

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

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

States a specific verb and resource ('Combine two solids') and enumerates the operation modes (add/unite, subtract, intersect, insert), which is clearly distinct from the many create_*/delete_solid siblings. It does not explicitly name a sibling it is not, but the boolean-operation framing is unambiguous.

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

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

There is no when-to-use/when-not guidance, no mention of prerequisites (both solids must exist), and no routing to alternatives. The agent must infer usage entirely from the phrase 'Combine two solids'.

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

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

No annotations are provided, so the description carries the full burden. It discloses the dynamic-dispatch nature but omits authentication needs, error behavior for invalid tool names, validation of args, or side effects of invoking arbitrary tools.

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

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

A single, front-loaded sentence with no filler; every word contributes to the core idea.

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

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

With no annotations, zero schema descriptions, and a non-trivial meta-invocation role, the description is too sparse. It omits usage context, argument handling, and failure modes, so an agent lacks enough to invoke it correctly beyond the most obvious case.

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

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

Schema description coverage is 0%, so the description must compensate. It only implies that tool_name is the tool's name ('by name'); it says nothing about the args object, its shape, or how arguments should be keyed, leaving half the parameters undocumented.

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

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

The description names the verb 'Call', the resource 'any registered CST MCP tool', and the mechanism 'through the registry (dynamic dispatch)'. It distinguishes the tool as a meta-invoker but does not contrast it with siblings like cst_runtime_invoke_tool or cst_toolbox_invoke_tool, so it is clear but lacks sibling differentiation.

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

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

There is no when-to-use guidance, no exclusions, and no named alternatives. An agent must infer that this is for dynamic dispatch rather than direct calls, which is not stated.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses one important trait (the CST session survives), but says nothing about whether unsaved project changes are discarded, whether a save prompt occurs, or whether the call fails if no project is active — all critical for a close/destroy operation.

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

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

A single eight-word sentence with the action front-loaded and zero filler. Nothing to trim.

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

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

An output schema exists, so return values need not be described. Still, for a state-mutating close operation with no annotations and no parameter surface, the description omits the one thing an agent most needs to know: what happens to unsaved work.

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

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

The tool takes zero parameters and the schema is trivially covered, so there is nothing for the description to clarify. Baseline 4 applies.

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

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

States a specific verb+resource ('Close the active project') and adds a scope clause ('without quitting CST') that implicitly separates it from the cst_quit_tool and cst_open_project_tool siblings. It does not name those siblings explicitly, but the intent is unambiguous.

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

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

The phrase 'without quitting CST' implies the usage context (tear down the project while keeping the session alive), which is reasonable inferred guidance. However, it never states when to prefer this over cst_quit_tool, cst_new_project_tool, or cst_save_project_tool, nor any prerequisite like saving first.

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

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

No annotations are provided, so the description carries the full burden. It doesn't disclose whether the configuration persists to the project, whether it overwrites a previously selected solver type, whether there are auth/connection requirements, or what happens to unspecified parameters. For a mutation tool with zero annotation coverage this is a real gap.

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

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

One front-loaded sentence with no filler, and the parenthetical efficiently enumerates the key settings. It is under-specified rather than verbose, so the economy is only slightly marred by the omitted parameters.

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

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

An output schema exists, so return values need not be explained, but with no annotations, 0% schema coverage on 5 params, and no usage context, the definition leaves an agent without enough to call the tool confidently. It should at least characterize method, accuracy, and mesh_type.

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

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

Schema description coverage is 0% across 5 parameters, so the description must compensate. It explains only n_modes and frequency; method, accuracy, and mesh_type are left undocumented in both the schema and the description, including the meaning of 'method' or acceptable mesh type values.

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

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

States a specific verb ('Configure') and resource ('the eigenmode solver'), which clearly separates it from the sibling configure_fd_solver and configure_td_solver tools. It also names two of the configurable settings, so the agent knows what kind of solver this targets.

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

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

No when-to-use guidance, no prerequisites (does a project need to be open? does a solver run need to follow?), and no explicit routing relative to the FD/TD solver configurators or set_solver. The parenthetical settings hint at use but do not guide selection.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not say whether existing solver settings are overwritten, whether defaults are applied when arguments are omitted, what permissions/state are required, or what happens on invalid values — significant gaps for a mutation tool.

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

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

A single front-loaded sentence with no filler, listing the configurable surface up front. It is a sentence fragment rather than prose, but it wastes no words.

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

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

An output schema exists so return values need no explanation, but for a 7-parameter mutation tool with no annotations and 0% schema coverage, the description omits two parameters, prerequisites, overwrite behavior, and the distinction from sibling solver-configuration tools.

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

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

Schema description coverage is 0%, so the description must compensate. It names 5 of the 7 parameters conceptually (mesh, sweep, order, accuracy, adaption) but omits max_cpus and double_precision entirely, and gives no valid-value semantics or format detail for the ones it does name.

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

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

States a specific verb (configure) and resource (frequency domain solver), and enumerates the settings it touches. The 'frequency domain' qualifier implicitly separates it from cst_configure_td_solver_tool and cst_configure_eigenmode_solver_tool, though it never names them explicitly.

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

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

No guidance on when to call this versus cst_set_solver_tool, cst_configure_td_solver_tool, or cst_run_solver_tool, and no prerequisites (e.g. project must be open, frequency range already set). Usage is only implied by the tool name.

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

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

No annotations are provided, so the description carries the full burden. It only restates the purpose and discloses nothing about what settings are changed, whether the operation is destructive, required permissions, or side effects.

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

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

A single, front-loaded sentence with no wasted words. It is appropriately concise for the amount of information conveyed.

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

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

With 6 parameters, an output schema, and no annotations, the description is severely incomplete. It omits all parameter semantics, usage context, and behavioral details, leaving the agent with little beyond the tool name.

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

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

Schema description coverage is 0% for 6 parameters. The description adds no parameter information, leaving all six parameters (accuracy, mesh_type, pulse_widths, etc.) undocumented in either the schema or description.

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

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

States a specific verb and resource: configuring the time domain solver. It distinguishes from frequency-domain and eigenmode solver configuration siblings by naming the solver type, but lacks explicit alternative routing.

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

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

No guidance on when to use this tool versus cst_set_solver_tool or other solver configuration tools, and no prerequisites or context provided.

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

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

With no annotations, the description carries the full behavioral burden. It conveys that a launch may occur as a side effect, but does not disclose what happens on failure, which environment is targeted when several exist, whether the operation is idempotent, or any auth/timeout behavior.

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

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

A single, front-loaded sentence with no filler. It earns its place, though the extreme brevity borders on under-specification for a session-establishing tool.

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

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

An output schema exists so return values need not be described, but with zero annotation coverage and 0% schema description coverage, the connection semantics (which environment, failure behavior, launch implications) are too thin for a tool that anchors the whole workflow.

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

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

Schema description coverage is 0%, so the description must compensate and only does so partially. 'Optionally launching one' loosely maps to launch_if_needed, but 'pid' is never explained, and defaults/semantics are left to the schema alone.

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

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

States a specific verb (Connect) and resource (running CST Design Environment) plus an optional launch behavior. It is distinguishable from cst_quit_tool and cst_detect_tool, though it doesn't explicitly name a sibling to route against.

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

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

No explicit when-to-use or when-not-to-use guidance. The phrase 'optionally launching one' hints that launch_if_needed exists but never says in which scenarios to prefer connecting over other session tools like cst_list_design_environments_tool.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Create' implies a model mutation, but the description does not disclose side effects, required project state, undo behavior, default material or wire-type behavior, or coordinate/unit expectations.

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

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

The description is a single front-loaded sentence with no wasted words. It is highly concise, though its brevity reflects under-specification rather than rich efficiency.

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

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

For a complex mutation tool with 8 parameters, 0% schema description coverage, and no annotations, the description is not complete enough. Although an output schema exists and reduces the need to explain return values, the description omits nearly all parameter and behavioral context needed to invoke the tool correctly.

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

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

Schema description coverage is 0% across 8 parameters. The description only implies that point1 and point2 are endpoints; it does not explain name, height, radius, material, wire_type, coordinate format, or units, leaving most parameters undocumented.

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

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

The description names a specific verb (Create) and resource (bond wire) and clarifies the core geometry as between two points. It distinguishes this tool from generic CST creation siblings like cst_create_brick_tool by resource, though it does not explain bond-wire-specific semantics.

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

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

There is no explicit when-to-use guidance, prerequisite setup, or routing to alternatives. The implied usage is creating a bond-wire geometry in an existing CST project, but the description leaves all context to inference.

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

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

No annotations are provided, so the description carries the full load. It states the mutating action and that the artifact lands in the history tree, but omits whether an open project is required, what happens on failure, whether the operation is undoable, and how the material/title defaults behave.

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

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

A single front-loaded sentence with no filler or redundancy. It is efficient, though arguably under-specified rather than optimally concise given the tool's 7-parameter surface.

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

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

The output schema covers return values, so that is not a gap. However, with no annotations, 0% parameter coverage, and no preconditions for a mutating geometry-creation tool, the definition leaves too much for the agent to infer before a safe call.

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

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

Schema description coverage is 0% across 7 parameters and the description mentions none of them. 'Rectangular brick (box)' faintly implies xrange/yrange/zrange are the box extents, but there is no guidance on their expected format (e.g. [min, max]), units, or the meaning of name/title/material/component. Almost all parameter meaning is left to inference.

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

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

Names a specific verb ('Create') and resource ('rectangular brick (box)'), and the shape reference implicitly distinguishes it from the many other create_* siblings (sphere, cylinder, cone, torus, bondwire). It could be sharper by noting it is a solid primitive added to a component, but an agent can route to it confidently.

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

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

No when-to-use guidance, no prerequisites (e.g. project/component must exist, whether a component must be open), and no comparison to alternative ways of creating geometry such as extrude or boolean. The phrase 'as a history block' hints at placement in the history tree but does not state the condition for choosing it.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Create' and does not describe permissions, coordinate system, what happens on success/failure, side effects, or whether existing geometry is affected.

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

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

The single sentence is concise and front-loaded, but it is under-specified for a 10-parameter creation tool. Brevity here reflects missing content rather than efficient communication.

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

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

Given 10 parameters, 0% schema coverage, no annotations, and a nontrivial geometry-creation operation, the description is contextually inadequate. Although an output schema exists, the agent still lacks the information needed to invoke the tool correctly.

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

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

Schema description coverage is 0%, and the description provides no meaning for any of the 10 parameters. Required parameters like axis, bottom_radius, top_radius, ranges, component, and name are completely undocumented in both structured and natural-language form.

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

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

The description states a specific verb (Create) and resource (cone or truncated cone). It is clear enough to distinguish from other creation siblings by shape name, though it does not explicitly differentiate itself from every sibling tool.

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

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

There is no guidance on when to use this tool, when not to use it, or what prerequisites or context are required. The agent must infer that this is the correct tool solely from the shape name.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a mutation ('Create') but does not disclose side effects, permission requirements, whether an active project/component is required, or what happens to existing geometry. This is a significant gap for a 9-parameter creation tool.

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

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

The single sentence is concise and front-loaded with no filler. But for a tool with nine parameters and five required inputs, it is severely under-specified rather than appropriately sized. It avoids verbosity but does not deliver enough structure for the tool's complexity.

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

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

An output schema exists, so return values need not be described. However, with no annotations, 0% input-schema description coverage, and nine parameters, the description is too sparse for correct invocation. It omits meaning for component, name, radius, ranges, center, material, segments, and title, leaving key required inputs unexplained.

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

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

Schema description coverage is 0%, so the description must compensate. It clarifies the axis parameter's allowed values ('x, y or z'), which is useful because the schema has no enum. However, eight other parameters—including required ones like component, name, radius, and ranges—receive no semantic explanation at all.

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

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

The description states a specific verb and resource: 'Create a cylinder' and adds the axis constraint 'along x, y or z.' It is clear what the tool does. However, it does not differentiate from the sibling cst_create_elliptical_cylinder_tool or other solid-creation tools, so it falls short of a 5.

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

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

The description provides no when-to-use, when-not-to-use, prerequisite, or alternative-tool guidance. It only states the operation and axis values. An agent must infer usage context entirely from the tool name and siblings.

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

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

No annotations are provided, so the description carries the full behavioral burden. It only restates the basic creation action and discloses nothing about side effects, required active context, coordinate conventions, error behavior, or persistence. It adds no behavioral information beyond the tool name.

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

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

The description is a single front-loaded sentence with no wasted words. It is concise and structurally clean, though its extreme brevity reflects under-specification rather than an efficient summary of necessary details.

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

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

For a 10-parameter CAD creation tool with 0% schema description coverage and no annotations, this description is critically incomplete. It provides no parameter guidance, no behavioral context, and no usage conditions, even though an output schema exists and could have been referenced.

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

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

The schema has 10 parameters with 0% description coverage, including 6 required parameters such as component, axis, xradius, yradius, and ranges. The description does not explain any parameter meaning, format, or constraints, leaving the agent with only bare titles.

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

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

The description states a specific verb and resource: 'Create an elliptical cylinder.' The adjective 'elliptical' implicitly distinguishes it from the sibling cst_create_cylinder_tool, which likely creates a circular cylinder. However, it does not explicitly call out that distinction or describe scope, so it is clear but not fully differentiated.

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

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

The description gives no guidance on when to use this tool versus alternatives such as cst_create_cylinder_tool or other primitive-creation tools. It also omits prerequisites like an active project or component. This is essentially no usage guidance.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure, yet it only lists physical properties. It does not state what happens on creation (e.g., whether an existing material is overwritten), what permissions are needed, or any side effects, leaving significant gaps for a mutation tool.

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

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

The description is a single, front-loaded sentence with no filler, and the parenthetical efficiently groups related properties. It is appropriately concise, though the extreme brevity contributes to the missing parameter and usage information noted elsewhere.

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

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

Given nine parameters, no annotations, and low schema description coverage, the description is far too sparse. It omits most parameters, usage context, and behavioral details, while only the output schema relieves it of explaining return values.

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

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

Schema description coverage is 0%, so the description must explain all 9 parameters, but it only names four concepts (permittivity, permeability, conductivity, loss tangent) and does not map them to specific parameter names like epsilon, mue, sigma, or tan_d. Parameters such as rho, colour, tan_d_freq, material_type, and the required name are entirely unaddressed.

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

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

The description states a specific verb (Define) and resource (material) and lists the key physical properties being set. The word 'explicitly' hints that this differs from loading a library material, but no sibling such as cst_load_material_from_library_tool is named to make the distinction unambiguous.

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

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

There is no explicit guidance on when to use this tool versus alternatives like cst_load_material_from_library_tool. 'Explicitly' weakly implies manual definition, but the description provides no conditions, prerequisites, or exclusions.

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

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

No annotations are supplied, so the description carries the full behavioral burden. It discloses that the sphere can be truncated via top/bottom radius, but says nothing about permissions, side effects on the active project/component, reversibility, or required context; for a mutating CAD primitive tool this is a major gap.

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

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

A single front-loaded sentence with no filler. It is structurally efficient, though its brevity is only a virtue in this dimension and does not offset missing detail elsewhere.

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

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

With 9 parameters at 0% schema description coverage, no annotations, and a mutating creation operation, the definition is not complete enough for reliable invocation. The output schema covers return values, but the description still omits most parameter semantics and behavioral context.

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

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

Schema description coverage is 0% across 9 parameters, so the description must compensate. It only explains the truncation effect of top_radius/bottom_radius and implicitly radius; center, component, name, title, material, and segments receive no meaning from the description.

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

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

Names a specific verb and resource ('Create a sphere'), and the parenthetical about top/bottom radius distinguishes it from an untruncated sphere primitive. Sibling tools like cst_create_cone_tool and cst_create_cylinder_tool are not named, so it does not explicitly route between primitives, but the purpose is still clear.

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

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

No guidance is given on when to use this versus cst_create_cone_tool, cst_create_cylinder_tool, or other solid-creation tools; no prerequisites or exclusions are stated. Usage is only implied by the tool name.

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

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

No annotations are provided, so the description carries full behavioral burden, yet it says nothing about side effects, prerequisites (open project/component), units/coordinate conventions, or persistence. Only the parameter mapping for the two radii is added, which is closer to parameter semantics than behavior.

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

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

A single front-loaded sentence with no filler; the parenthetical is compact. It is terse to the point of under-specification, but the size itself is appropriate and well-ordered.

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

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

An output schema exists so return values need not be described, but for a 9-parameter geometry tool with no annotations and no schema descriptions, the description leaves critical invocation context (required component/name/center, axis default, units) unaddressed. It is not complete enough for reliable calling.

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

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

Schema description coverage is 0% across 9 parameters with 5 required, and the description only restates two radii (ring_radius = ring, tube_radius = tube) in a way that adds essentially no meaning beyond the field titles. Nothing is said about center format, axis, material, segments, or component.

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

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

The description states a specific verb and resource ("Create a torus") and clarifies the semantic mapping for the two radius parameters. It is clearly distinguishable from shape siblings like cst_create_sphere_tool or cst_create_brick_tool by name and object. It lacks any sibling cross-reference, but the purpose is unambiguous.

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

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

There is no indication of when to use this versus other creation tools, nor any prerequisites such as requiring an open project or an existing component. The required 'component' parameter implies context but the description never states it.

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

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

No annotations are provided, so the description carries the full behavioral burden. It conveys that this is a batch create/update operation, but does not explain overwrite behavior, persistence semantics, or what happens to existing parameter definitions.

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

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

The description is a single, front-loaded sentence with no wasted words. It directly states action and context.

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

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

For a mutation tool with no annotations, a nested object parameter, and 0% schema description coverage, the description is too thin. The output schema reduces the need to explain return values, but input semantics and side effects are missing.

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

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

Schema description coverage is 0%, and the description does not compensate. It hints that the `parameters` argument accepts several definitions, but gives no format, nesting, or value semantics, and never explains the optional `save` boolean.

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

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

The description states a specific verb+resource: create or update several parameters at once. It also gives a modelling context as the usual first step. However, it does not explicitly distinguish itself from the sibling cst_set_parameters_tool, so it falls short of a 5.

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

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

The phrase 'the usual first modelling step' gives clear contextual guidance for when this tool is used. It does not state when not to use it or name alternatives such as cst_set_parameters_tool.

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

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

Annotations are absent, so the description carries the full behavioral burden for a destructive mutation. It says nothing about irreversibility, whether deletion fails if the parameter is in use by geometry or the model, whether an error is raised for unknown names, or whether the deletion is persisted to the project.

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

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

A single front-loaded sentence with no filler; nothing is wasted. It is perhaps too terse to be truly optimal, but structurally sound.

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

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

An output schema exists, so return values need not be explained, but for a destructive tool with no annotations and an undocumented parameter, the description omits error behavior, dependencies, and side effects that an agent needs before invoking it.

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

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

Schema description coverage is 0% for the single 'name' parameter, so the description would need to compensate but does not — it never clarifies whether 'name' is the existing parameter's identifier, whether it is case-sensitive, or what form it takes. Only the near self-evident naming keeps this above 1.

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

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

Specific verb 'Delete' plus resource 'design parameter from the parameter list' — an agent knows exactly what operation is performed. However, it does nothing to distinguish itself from siblings like cst_set_parameters_tool, cst_get_parameters_tool, or cst_define_parameters_tool, so sibling differentiation is absent.

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

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

No when-to-use guidance, no prerequisites, and no mention of alternatives such as editing a parameter via cst_set_parameters_tool instead of deleting it. The description only restates the operation.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing beyond the bare operation. It does not state that deletion is destructive and irreversible, whether dependent objects (components, materials, ports referencing the solid) are affected, or whether a failure occurs if the name is not found.

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

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

A single front-loaded sentence with no filler, which is structurally ideal for a simple tool. The brevity is efficient rather than padded, though it errs toward under-specification for a destructive operation.

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

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

An output schema exists, so return values need not be described, but for a destructive mutation with no annotations and an undocumented parameter the description is too thin. An agent cannot determine irreversibility, side effects, or parameter format from it.

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

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

The single required parameter 'name' has 0% schema description coverage, and the description never mentions it. It is left unstated whether 'name' is the solid's exact model name, whether it is case-sensitive, or whether a pattern/prefix is accepted.

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

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

The description states a specific verb (Delete) and resource (a solid from the model), which is unambiguous and distinguishable from other deletion tools like cst_delete_parameter_tool. However, it offers no differentiation from any of the ~60 sibling tools beyond the noun 'solid', and does not clarify scope such as whether it targets the active project/model.

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

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

There is no guidance on when to use this tool versus alternatives, no prerequisites (e.g., a project must be open, the solid must exist), and no warning about when not to use it. The agent is left to infer everything from the name alone.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not state whether detection is read-only, what permissions are required, whether it has side effects, or how it performs detection. Only the purpose is given, with no additional behavioral context.

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

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

A single, front-loaded sentence that efficiently conveys the tool's purpose without any redundant or filler text.

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

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

Given the tool's low complexity, empty input schema, and existing output schema, the description covers the basic purpose. However, it omits any usage context or behavioral details (e.g., read-only nature, prerequisites) that would help an agent decide when to invoke it, making it minimally adequate.

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

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

The tool takes zero parameters, so per the rubric baseline is 4. The schema is empty and fully covered, so no parameter semantics need to be added in the description.

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

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

The description states a specific verb 'Detect' and three concrete resources: CST executable, automation libraries, and running Design Environments. This is clear and distinct from generic detection tools. However, it does not explicitly differentiate itself from sibling tools like cst_runtime_detect_tool or cst_list_design_environments_tool, leaving some ambiguity about when this tool is preferred over those.

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

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

The description provides no when-to-use guidance, no prerequisites, and no mention of alternatives. It only states what the tool detects, leaving the agent to infer context from the name and siblings.

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

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

No annotations are provided, so the description carries the full burden. It does not say whether this is a read-only operation, whether it can trigger or require a solver run, what happens if no project is open, or whether cst_file null means the current project. Only the returned quantities are hinted at.

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

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

A single front-loaded sentence with no filler; the parenthetical breakdown of result categories is useful and earns its place.

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

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

An output schema exists, so return formatting need not be explained, but for a zero-annotation, zero-schema-coverage tool the description omits prerequisites, safety profile, and parameter meaning. An agent could easily invoke it without a solved project and get nothing back with no explanation.

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

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

Schema description coverage is 0% and there are two parameters. The description only implies that frequency is the evaluation point; it never explains units (the schema default 2.4 suggests GHz but does not say so) or what cst_file does versus the default null. The schema's bare anyOf string/null gives the agent nothing, so the description should have compensated and does not.

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

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

States a specific verb (Report) and resource (power budget and efficiencies), and names the decomposition it returns (radiated / accepted / losses). That is materially clearer than a tautology, but it does not distinguish itself from nearby result-reading siblings such as cst_read_result_tool or cst_frequency_overview_tool.

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

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

There is no when-to-use or when-not-to-use guidance and no mention of alternatives among the many cst_* result tools. Prerequisites (must a project be open, must a solver run have completed) are also absent, so the agent has to infer whether calling this is even valid.

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

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

No annotations are supplied, so the description carries the full behavioral burden. It does not disclose that this writes a file to disk, whether an existing file is overwritten, what 'ASCII/CSV' means for complex data, or any permission/error behavior; for a write-to-disk tool this is a significant gap.

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

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

A single tight sentence with the action front-loaded and no filler. It is efficient, though it is arguably too terse for the amount of undocumented surface it leaves behind.

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

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

An output schema exists, so return values need not be described, but with zero annotation coverage, 0% schema description coverage, and an unexplained 'mode' parameter, the definition does not give an agent enough to invoke this tool confidently.

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

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

Schema description coverage is 0% and the description only loosely implies two of the three parameters ('result tree item' → tree_path, 'ASCII/CSV file' → filename). The 'mode' parameter with its RealImag default is never explained, leaving the caller unable to know what values are valid.

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

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

States a specific verb (Export), a specific resource (one result tree item), and the output format (ASCII/CSV). It is distinguishable from cst_export_touchstone_tool, though it never names siblings or scope limits explicitly.

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

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

The phrase 'for external checking' gestures at motivation but gives no when-to-use condition, no prerequisites, and no comparison against alternatives like cst_export_touchstone_tool or cst_read_result_tool that might return the same data.

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

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

No annotations are provided, so the description carries the full behavioral burden; it states only the core operation. It omits overwrite behavior, required prior results, file-path constraints, and whether the impedance choice affects other settings — all material for a file-writing tool.

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

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

A single front-loaded sentence with the action first and no wasted words. It is efficiently sized for the information it contains, though that information is sparse.

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

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

An output schema exists so return values need not be explained, but with no annotations and zero parameter documentation, the description is too sparse to call the tool correctly. It does not describe the enum-like choices for data_format, export_type, or frequency_range.

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

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

Schema description coverage is 0% and five parameters are present, but the description only clarifies 'impedance' via 'chosen reference impedance'. It gives no meaning for data_format, export_type, or frequency_range, so it does not compensate for the schema gap.

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

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

States a specific verb (Export) and resource (S-parameters as a Touchstone file), and adds the reference-impedance condition. This distinguishes it from sibling cst_export_ascii_tool by output format, so an agent can identify it without opening the schema.

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

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

No when-to-use guidance, prerequisites, or alternatives are given. It does not mention when to prefer this tool over cst_export_ascii_tool or any other export path, leaving selection entirely to inference.

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

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

No annotations are provided, so the description must disclose behavioral traits. It implies a solid is created and that the input curve must be closed and planar, which is useful, but it does not describe side effects, required component context, failure conditions, or what happens to the existing model.

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

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

The description is a single front-loaded sentence with no filler. It is efficiently structured, although for an 8-parameter modeling operation it is arguably terse rather than fully sized.

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

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

An output schema exists, so return values do not need to be described. However, with no annotations and 0% schema description coverage across 8 parameters, the description is far too thin to make the tool reliably callable without additional inference.

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

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

There are 8 parameters with 0% schema description coverage, so the description must carry parameter meaning. It only constrains the curve argument as closed and planar and never explains component, name, thickness, taper, twist, material, or title, leaving most parameters undocumented.

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

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

The description has a specific verb (Extrude), resource (closed planar curve item), and result (solid). It clearly distinguishes this from generic modeling tools such as create_brick or boolean, though it does not explicitly name when to use it over those siblings.

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

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

The description states what the tool does but gives no when-to-use guidance, no exclusions, and no alternatives. An agent would have to infer that this is the correct tool for extruding a closed planar curve rather than another solid-creation or transform tool.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Report' implies a read with no side effects, but the description never states that explicitly, nor does it mention permissions, prerequisites, or whether any state is touched.

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

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

One sentence, front-loaded with the verb and the full set of reported items. No filler and nothing to trim.

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

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

An output schema exists, so return-value documentation is not needed, and with zero parameters the surface is small. The description covers what is reported, but omits any usage context such as when this overview is preferable to the individual getter tools.

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

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

The tool takes zero parameters, so there is nothing for the description to clarify; baseline 4 applies.

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

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

States a specific verb ('Report') and enumerates exactly what is returned: solver, solver frequency range, and every monitor frequency. The 'in one view' framing implicitly separates it from the narrower cst_get_solver_tool and cst_list_monitors_tool, though it never names them explicitly.

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

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

No when-to-use or when-not-to-use guidance. The phrase 'in one view' hints that this is the aggregate alternative to the individual getter/list tools, but neither that alternative nor any prerequisite (e.g. an open project) is stated.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states a limitation but says nothing about what happens when the tool is called, whether it returns a message, errors out, or has side effects. This is inadequate transparency for any invocable tool.

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

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

The description is a single short sentence, so it is not verbose. However, it is under-specified rather than appropriately concise: it does not front-load a usable purpose or actionable guidance, and the one sentence does not earn its place as a tool description.

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

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

An output schema exists, so return values need not be explained. Still, the description omits critical context such as whether this tool is a stub, what it actually does, and what an agent should use instead for mesh operations. For a generate tool with a contradictory-sounding limitation, this is incomplete.

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

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

The tool has zero parameters and schema description coverage is 100%, so there are no parameter semantics to document. The description does not need to add parameter information, making the baseline 4 appropriate.

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

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

The description does not state what the tool does. It only asserts that mesh generation is not exposed through CST's VBA API, which is a negative limitation rather than a specific verb and resource. For a tool named cst_generate_mesh_tool, this leaves the actual purpose unclear and potentially misleading.

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

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

There is no guidance on when or when not to use this tool. It does not name an alternative such as cst_set_mesh_tool, nor does it explain whether the tool should ever be invoked. An agent is left with no routing information.

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

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

No annotations are provided, so the description carries the full burden. It implies a safe read-only operation and scopes it to the 'active project', but does not state auth/permission needs, behavior when no project is active, or that it is non-mutating in explicit terms.

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

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

A single tight sentence with the verb and scope front-loaded and zero wasted words.

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

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

An output schema exists, so return values need not be described, and there are no parameters to document. The only real gap is the absence of usage/alternative context, which for a simple getter is a minor omission.

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

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

The tool takes zero parameters, so the baseline is 4. The description correctly adds no parameter detail that would be redundant, and the parenthetical '(name and value)' documents the only meaningful output semantics.

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

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

States a specific verb ('Read') and resource ('every design parameter of the active project'), and even clarifies the returned fields ('name and value'). It is clearly distinguishable from the write-side siblings like cst_set_parameters_tool, though it does not name them explicitly.

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

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

There is no when-to-use guidance, no prerequisites (e.g., must a project be open?), and no mention of alternatives such as cst_set_parameters_tool or cst_define_parameters_tool. Usage is only implied by the verb 'Read'.

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

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

With no annotations, the description carries the full burden, but the verb 'Read' clearly communicates a non-mutating, side-effect-free operation. It does not add details about connection requirements, error behavior, or safety beyond what the verb implies.

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

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

A single front-loaded sentence with no wasted words. It is appropriately sized for a zero-parameter getter.

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

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

Given the simple nature, zero parameters, and the presence of an output schema, the description is minimally sufficient. It could better explain what 'active solver' means or how this relates to set/configure solver tools, but it covers the essential operation.

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

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

The tool accepts zero parameters, so the baseline of 4 applies. The description does not need to explain parameter semantics because there are none.

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

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

States a specific verb ('Read') and resource ('currently active solver'), making the operation immediately clear. It implicitly distinguishes from sibling mutators like cst_set_solver_tool, though it does not name any alternative explicitly.

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

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

No guidance on when to use this tool versus alternatives such as cst_set_solver_tool or cst_configure_*_solver_tool. Usage is only implied by the tool name and description.

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

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

No annotations are provided, so the description carries the full behavioral burden. The word 'Check' implies a non-mutating diagnostic and the listed targets define scope, but it does not explicitly state read-only behavior, side effects, or required permissions. With an output schema present, return details need not be explained.

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

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

A single sentence, front-loaded with the verb and the list of checked components. Every word earns its place and there is no redundancy.

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

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

For a zero-parameter diagnostic tool with an output schema, the description identifies all checks performed and is sufficient to invoke the tool. It lacks sibling differentiation and usage context, but the core invocation context is complete.

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

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

The tool has zero parameters, so the baseline is 4. Schema coverage is 100% and there are no parameters for the description to clarify; no parameter semantics are needed.

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

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

States the verb 'Check' and enumerates four specific targets: CST install, Python libraries, workspace, and running Design Environments. The purpose is clear, but the description does not differentiate this tool from sibling diagnostic tools such as cst_detect_tool, cst_toolbox_detect_tool, or cst_runtime_detect_tool.

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

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

No when-to-use guidance, prerequisites, or alternatives are provided. The description does not tell the agent when to prefer this health check over other detection or environment-listing siblings like cst_detect_tool or cst_list_design_environments_tool.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It discloses the key filter ('running') and that the return is PIDs, but it does not state permissions, side-effect profile, or edge-case behavior. For a simple read operation this is adequate but not rich.

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

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

The description is a single sentence with zero waste. It front-loads the action and result, making it immediately readable.

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

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

Given the low complexity, zero parameters, and the presence of an output schema, the description is nearly complete for calling the tool. It states the returned content (PIDs) and scope (running environments), though it omits minor context such as whether an empty result is possible.

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

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

The input schema has zero parameters, and the rules assign a baseline of 4 for zero-parameter tools. The description adds no parameter information because none is needed.

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

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

The description states a specific verb ('List') and resource ('PIDs of running CST Design Environments'), so an agent can tell what the tool does. It does not explicitly differentiate itself from the many sibling tools, but the resource is distinctive enough to avoid confusion.

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

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

There is no guidance on when to use this tool, no prerequisites, and no alternatives named among the extensive sibling tools. The description only implies usage through the operation itself, leaving the agent to infer context.

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

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

No annotations are provided, so the description carries the full burden. It implies a read-only enumeration but says nothing about whether a CST connection is required, whether results are paginated, or the scope of 'every' (all 80+ tools vs. a category subset).

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

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

A single front-loaded sentence with no filler. It is efficient, though its brevity is partly the cause of the semantic gaps rather than a virtue of precision.

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

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

An output schema exists, so return-value explanation is not required. Still, for a catalog tool in a crowded sibling set, the description omits the filtering behavior and the relationship to the other list/manifest tools, which is the context an agent needs to select it correctly.

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

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

Schema description coverage is 0% for the single 'category' parameter. The description mentions 'category' only as a returned field, not as a filter argument, so it actively fails to clarify whether passing category narrows the list or is ignored. That leaves the parameter's semantics undocumented in both schema and description.

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

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

States a specific verb+resource (list every CST MCP tool) and describes the payload (category, summary, parameters). However, it offers no differentiation from near-identical siblings such as cst_tool_manifest_tool, cst_toolbox_list_tools_tool, and cst_runtime_list_tools_tool, leaving the agent guessing which lister to call.

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

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

No when-to-use context, no prerequisites, and no mention of the competing list tools. The agent gets no signal about when this catalog is the right choice versus the manifest or toolbox listers.

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

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

No annotations are provided, so the description carries the disclosure burden, but 'List' inherently signals a non-mutating read of low risk. It omits any statement about whether a project must be open or what happens when no monitors exist, though the has_output_schema flag means return details are handled elsewhere.

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

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

One short sentence with the resource and scope front-loaded and no filler. Every word earns its place.

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

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

Given zero parameters and an existing output schema, the description needs only to identify the resource and any preconditions. It identifies the resource but omits the precondition context (open project) and any sibling differentiation, leaving a small but real gap.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline for a 0-param tool is 4.

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

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

States a specific verb+resource (list monitors) scoped to the project, so the agent knows exactly what it retrieves. It does not distinguish itself from sibling list-style tools (e.g. cst_list_ports_tool, cst_list_results_tool) or from cst_add_monitor_tool, so it falls short of a 5.

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

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

The description offers no when-to-use guidance, no prerequisites (e.g. a project must be open), and no mention of alternatives. Usage is only implied by the verb 'List'.

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

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

With no annotations provided, the description carries the full behavioral burden. It implies a read-only enumeration of project ports, which is naturally non-destructive, but does not explicitly state read-only safety, permissions, or other behavioral traits. The added context that it returns port types is useful but limited.

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

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

The description is a single, front-loaded sentence with no wasted words. It efficiently communicates the tool's scope and return content.

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

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

For a no-parameter list tool, the description is largely complete. An output schema exists, so return details need not be explained. The only minor gap is lack of routing guidance relative to sibling port-info tools, but the essential purpose is clear.

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

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

The tool has zero input parameters, and the schema is an empty object. Per the rubric, zero parameters set the baseline at 4, since there is nothing for the description to compensate for.

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

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

The description states a specific verb and resource: list the ports defined in the project and their types. It clearly identifies the tool's function, but does not differentiate it from sibling tools such as cst_read_port_info_tool or the add-port tools.

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

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

There is no explicit guidance on when to use this tool versus alternatives like cst_read_port_info_tool. Usage is only implied by the description's purpose statement, with no context or exclusions provided.

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

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

The verb 'List' implies a read-only operation, which provides minimum viable behavioral transparency even without annotations. However, the description does not explicitly confirm that no mutation occurs, nor does it mention permissions, side effects, or any other behavioral trait that would fully carry the burden in the absence of annotations.

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

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

The description is a single front-loaded sentence with no wasted words. It is appropriately sized for the basic purpose it communicates.

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

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

Given 0% schema description coverage, no annotations, and a domain with many closely related read tools, the description is incomplete. An agent cannot confidently determine how to specify the project/file or when to choose this tool over cst_read_result_tool, though the presence of an output schema reduces the need to explain return values.

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

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

Schema description coverage is 0%, so the description must compensate. The phrase '3D or schematic result tree' weakly hints that the module parameter selects between 3D and schematic modes, but it never names either parameter and gives no information about the cst_file parameter, leaving most parameter semantics undocumented.

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

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

The description states a specific verb ('List') and resource ('items of the 3D or schematic result tree'), making the tool's basic purpose clear. However, it does not differentiate this tool from siblings such as cst_read_result_tool or cst_read_s11_tool, so an agent must infer the distinction from context.

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

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

There is no guidance on when to use this tool versus alternatives, no prerequisites, and no explicit context beyond the bare purpose. The agent receives no help in deciding between listing result-tree items and reading specific results or S-parameters.

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

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

With no annotations, the description carries the full behavioral burden and does not meet it. It says nothing about the significant 'replace' flag (defaulting to true), i.e. whether an existing material of the same name is overwritten, nor about required state, permissions, or side effects.

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

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

A single front-loaded sentence with no filler or repetition. It is efficient, though the brevity is a symptom of under-specification rather than disciplined economy.

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

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

For a mutating tool with no annotations and zero schema description coverage, the description is too thin. An output schema exists so return values need not be explained, but the destructive/overwrite behavior implied by replace=true and the required library_path are gaps the agent cannot fill from structured data.

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

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

Schema description coverage is 0%, and the description adds no meaning for any of the three parameters. The required library_path format, the purpose of material_name (which is nullable with a null default), and the replace semantics are all left undocumented.

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

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

States a specific verb (add/load) and resource (material from the CST material library), so an agent knows the operation. It does not, however, distinguish itself from nearby siblings like cst_create_material_tool or cst_assign_material_tool, leaving the agent to infer which of the three material-related tools applies.

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

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

No when-to-use guidance, no prerequisites, and no mention of the alternative material tools. The agent is never told whether this supplements or conflicts with creating a material or assigning one to a solid.

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

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

With no annotations, the description carries the full burden: 'Read' implies a non-mutating operation and the severity list hints at what is logged. However, it says nothing about ordering, whether the window is cleared, how many messages exist, or any rate/permission context, so a 3 reflects modest added value.

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

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

A single tight sentence with the verb and resource front-loaded and no filler. It is efficient, though the terse parenthetical is the only structural aid.

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

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

An output schema exists, so return-value explanation is not required, and the tool has no required parameters. Still, with zero schema description coverage and no annotations, the description should have covered what the two parameters do, which it omits.

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

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

Schema description coverage is 0% and the description never mentions 'limit' or 'errors_only'. The INFO/WARNING/ERROR list gestures at severity filtering but does not explain how 'errors_only' maps to ERROR-only retrieval or what 'limit' bounds. Two undocumented parameters leave the semantics gap unclosed.

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

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

States a specific verb ('Read') and resource ('the CST message window') and enumerates the severity content (INFO/WARNING/ERROR), so the agent knows exactly what it returns. It does not differentiate itself from adjacent diagnostic siblings like cst_health_check_tool or cst_read_result_tool, which keeps it short of a 5.

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

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

There is no statement of when to use this tool versus the many other diagnostics/read tools in the sibling list, nor any prerequisite or exclusion. Usage must be inferred solely from the name and the parenthetical severity list.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses little. It does not say the operation is read-only, that it requires an open/built project, or whether it is expensive or has side effects. It only lists the categories inspected.

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

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

A single sentence with the verb and the inspected categories front-loaded, and no wasted words.

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

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

An output schema exists, so return values need not be explained in the description. For a zero-parameter read tool this is close to sufficient, with the only real gap being prerequisites and the read-only nature that annotations would otherwise supply.

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

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

The tool takes zero parameters, so there is no parameter semantics to document; per the rubric this is the baseline 4. The description appropriately adds no parameter detail.

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

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

The description names a specific verb (audit) and resource (the built model) and enumerates what is inspected: solids, materials, volumes, bounding boxes. That is far more informative than a tautology, though it does not explicitly contrast itself with siblings like cst_project_info_tool or cst_health_check_tool.

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

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

There is no indication of when to reach for this tool versus the many other inspection/reporting siblings (cst_project_info_tool, cst_health_check_tool, cst_list_results_tool). No prerequisites (e.g. project must be open and a model built) are stated.

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

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

No annotations are provided, so the description carries the full burden for a mutating tool. It does not say whether the solid is removed from its original component, whether the move is reversible, what happens if the target component is invalid, or what the caller needs (open project, active design environment). Only the bare mutation is implied.

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

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

A single front-loaded sentence with no filler or redundancy. It is efficient, though its brevity is the same brevity that leaves the semantic gaps elsewhere.

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

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

An output schema exists, so return values need not be explained, but for a two-parameter mutation tool with zero annotation and zero schema-description coverage, the definition omits essentially all operational context (preconditions, side effects, error cases). It is not adequate to invoke the tool confidently.

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

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

Both parameters have 0% schema description coverage — the schema gives only the titles 'Solid' and 'Component' with no format. The description adds nothing about whether these are names, IDs, or hierarchical paths, which is exactly the gap the description should fill.

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

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

States a specific verb and resource ('Move a solid') plus the destination ('into another component'), so the operation is unambiguous. It does not differentiate itself from adjacent sibling tools like cst_new_component_tool or cst_rename_solid_tool, which is the only thing keeping it from a 5.

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

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

The description gives no when-to-use context, no prerequisites (must the component already exist? must the solid be selected?), and names no alternative tool. An agent must infer everything about routing from the name alone.

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

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

Annotations are absent, so the description carries the full burden. It usefully notes the component is '(empty)' and lives in the model tree, but says nothing about whether a project must already be open, whether names must be unique, whether the operation is undoable, or what side effects occur. Significant behavioral gaps for a mutating tool.

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

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

A single efficient sentence with the core action front-loaded and no filler. Sized appropriately for the tool's simplicity, though it leaves room to spend words on the missing guidance.

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

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

An output schema exists, so return values need no explanation, and only one parameter is involved. However, with no annotations and a mutating operation, the description should address project-state prerequisites and how the new component relates to solids; as written, gaps remain that an agent would have to discover by trial.

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

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

There is one required parameter ('name') with 0% schema description coverage, and the description never mentions it, its format, or naming constraints. The parameter's meaning is somewhat self-evident, but the description adds no semantics beyond the bare schema.

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

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

States a specific verb ('Create') and resource ('a new (empty) component in the model tree'), which is enough to separate it from create_solid-style siblings and from cst_move_solid_to_component_tool. It stops short of explicitly differentiating from sibling tools, so it lands just below the top band.

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

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

No when-to-use, prerequisites, or alternatives are given. An agent must infer from the name alone that this is the tool to reach for before populating a tree component, and there is no mention of what state the project must be in.

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

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

With no annotations, the description carries the full burden, and it does disclose one important side effect — the project is persisted to the workspace right away, unlike a purely in-memory create. It still omits whether an existing project at the path is overwritten, permission/connection requirements, and any failure semantics.

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

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

One tight sentence with no filler, and the immediate-save detail is front-loaded alongside the action. Efficient, though barely enough content to work with.

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

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

An output schema exists, so return values need not be explained, but for a mutation tool with zero annotations and two fully undocumented parameters the single sentence is far too thin. An agent cannot tell where the project is created or what type it will be.

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

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

Schema description coverage is 0% for both parameters, so the description must compensate, and it does not. It never explains what 'path' represents (workspace location? file path? nullable means default?) or what 'project_type' values like the 'mws' default signify.

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

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

The description gives a specific verb+resource ('Create a new CST project') plus the persistence behavior. It does not distinguish itself from siblings such as cst_new_component_tool or cst_open_project_tool, but the resource being a project (not a component) makes intent readable.

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

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

There is no indication of when to use this versus cst_open_project_tool or cst_new_component_tool, nor prerequisites like an active connection. The 'save it into the workspace immediately' phrase implies a workflow but no exclusions or alternatives are named.

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

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

With no annotations, the description carries full behavioral burden but discloses little. It implies a connection precondition but says nothing about what happens if a project is already open, whether it overwrites current state, or how failures surface for this state-changing operation.

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

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

A single front-loaded sentence with zero filler. Every word earns its place; the verb and scope lead the sentence.

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

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

An output schema exists, so return values need no explanation. However, for a state-changing tool with no annotations and an undocumented path parameter, the description omits the operational context (connection precondition, current-project handling) an agent needs.

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

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

There is one parameter ('path') at 0% schema coverage, and the description adds no meaning: it does not clarify absolute vs relative paths, expected extension, or environment requirements. The description fails to compensate for the coverage gap.

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

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

States a specific verb ('Open') and resource ('.cst project') plus scope ('connected Design Environment'). This distinguishes it from cst_new_project_tool and cst_close_project_tool implicitly, though it does not explicitly name them.

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

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

There is no when-to-use guidance, no prerequisites (e.g., must be connected first), and no alternatives named. The only hint is 'in the connected Design Environment,' which is context rather than directive.

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

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

With no annotations provided, the description must carry the full burden of behavioral disclosure. It implies a read-only operation via 'Report' but does not state that explicitly, nor does it mention prerequisites, side effects, authentication needs, or any other behavioral traits.

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

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

The description is a single, efficient sentence with no wasted words. It front-loads the core purpose and lists the reported items compactly.

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

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

The description is minimally viable for a no-parameter info tool, especially since an output schema exists and return values need not be explained. However, it lacks differentiation from sibling tools and provides no usage context, which are notable gaps given the many similar project-related tools available.

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

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

The tool takes zero parameters, so the baseline score is 4. The description appropriately does not attempt to describe parameters, and there are no semantics to clarify.

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

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

The description states a clear verb ('Report') and lists three specific resources: the active project, all open projects, and recent CST messages. It does not differentiate this tool from siblings such as cst_messages_tool or cst_list_design_environments_tool, which likely overlap in function.

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

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

There is no guidance on when to use this tool versus alternatives. The description only implies usage by stating what it reports, with no explicit when/when-not conditions or alternative tool mentions.

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

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

With no annotations, the description must disclose behavioral traits fully. It states that all open projects are closed and the process is released, but omits critical context for a destructive operation: whether unsaved changes are lost, whether a confirmation is required, and whether the action is irreversible.

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

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

The description is a single, front-loaded sentence that efficiently conveys the core action and scope. Every word earns its place with no redundancy.

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

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

For a zero-parameter, destructive quit tool with no annotations, the description is minimally adequate: it names the effects but leaves out important behavioral warnings such as data loss risk. An output schema exists, so return values need not be explained, but the lack of safety context for a destructive operation is a gap.

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

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

The tool takes zero parameters, so there are no parameter semantics to clarify. The baseline for a parameterless tool is 4, and the description appropriately avoids discussing nonexistent inputs.

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

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

States a specific verb ('Close') and resource ('every open project'), plus the additional effect of releasing the Design Environment process. This distinguishes it from siblings like cst_close_project_tool, which likely closes a single project, by emphasizing the global scope.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives such as cst_close_project_tool or cst_save_project_tool. While the name 'quit' implies a final shutdown, there is no mention of prerequisites, alternatives, or when-not-to-use conditions.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Read' implies a safe non-mutating call, but the description says nothing about prerequisites, whether cst_file/operating_frequency are needed, error behavior if no port exists, or how the mode data is scoped. It essentially only restates the return contents.

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

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

A single tight sentence that front-loads the verb and resource, then lists the returned quantities. No padding, though it is arguably under-specified rather than efficient.

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

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

An output schema exists, so return values need not be re-explained, but the description leaves the two input parameters completely unexplained and offers no usage context for a CST port-inspection tool surrounded by many similar read siblings. It is not complete enough for an agent to call it confidently.

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

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

Schema description coverage is 0% and the description never mentions either parameter (cst_file, operating_frequency) — not even that they exist or that both default to null. With two undocumented parameters, the description does nothing to compensate for the schema gap.

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

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

States a specific verb ('Read') and resource ('port mode information'), and enumerates the concrete outputs (cutoff frequency, wave impedance, effective permittivity). It does not differentiate itself from nearby siblings such as cst_read_reference_impedance_tool or cst_list_ports_tool, so an agent must infer the boundary itself.

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

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

There is no statement of when to call this tool, what preconditions are needed (e.g., a port must exist, a project must be open), or which sibling to use for related port queries. The agent gets the what but not the when.

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

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

No annotations are provided, so the description carries the full burden. "Read" implies a non-mutating operation and the matching caveat adds a useful interpretive constraint, but nothing is said about behavior with no cst_file supplied (default null), error handling, or project-scoping.

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

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

A single, front-loaded sentence with no filler. The trailing clause is slightly cryptic but earns its place as a usage caution, so the sizing is appropriate.

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

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

An output schema exists, so return values needn't be described, but the tool omits any explanation of cst_file (including null/default semantics) and has no annotation coverage to lean on. For a callable read tool, an agent lacks the info needed to invoke it confidently.

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

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

There is one parameter, cst_file, with 0% schema description coverage and a null default whose meaning is unexplained. The description never mentions the parameter at all, so it fails to compensate for the schema gap.

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

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

States a specific verb (read) and resource (S-parameter reference impedance, ZRef), which is narrow enough to distinguish it from siblings like cst_read_s11_tool or cst_read_result_tool. It does not explicitly name or rule out those siblings, but the resource is precise.

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

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

"Must match the impedance you intend" implies the workflow context (use the returned ZRef to align with your simulation intent), but it never states when to call this versus alternatives or any prerequisite for the call. Usage is inferred rather than directed.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Read' implies a non-mutating operation, but the description says nothing about permissions, side effects, error conditions, or other operational constraints.

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

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

The description is a single, front-loaded sentence with no wasted words. It is concise and easy to parse, though its brevity leaves important details unstated.

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

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

An output schema exists, so return values need not be explained. However, with five input parameters at 0% schema coverage and no annotations, the description is too sparse to make the tool safely and unambiguously callable.

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

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

Schema description coverage is 0%, with five parameters including tree_path, module, cst_file, max_points, and at_frequency. The description mentions none of these parameters or their meaning, so it does not compensate for the missing schema documentation.

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

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

The description gives a specific verb and resource: 'Read a 1D result tree item' and names example result types. It is clear what the tool does, but it does not distinguish itself from sibling tools like cst_read_s11_tool or cst_list_results_tool.

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

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

The description provides no when-to-use guidance, prerequisites, or alternatives. It only implies that the tool retrieves result data, leaving the agent to infer when this tool is preferable to cst_read_s11_tool or cst_list_results_tool.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read-only operation and specifies the output unit (dB), but it does not disclose prerequisites such as whether a project must be open, error behavior, or any side effects.

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

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

The description is a single, front-loaded sentence with no wasted words. It states the action, the result, and the usage context compactly.

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

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

An output schema exists, so return format does not need explanation in the description. However, with no annotations, 0% schema description coverage, and three parameters, the description is somewhat under-informative about prerequisites and the roles of cst_file and tree_path.

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

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

Schema description coverage is 0%, so the description must compensate for missing parameter documentation. It explains target_frequency by stating the result is reported in dB at a target frequency, but it does not clarify cst_file or tree_path, leaving two of three parameters without meaningful semantic support.

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

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

The description states a specific verb and resource: read S11 and report it in dB at a target frequency. This clearly tells an agent what the tool does, though it does not explicitly distinguish itself from sibling tools such as cst_read_result_tool or cst_read_port_info_tool.

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

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

The phrase 'the usual acceptance check' gives implied usage context, indicating this is a common validation operation. However, it does not specify when to use this instead of alternatives, nor does it state prerequisites or exclusions.

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