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

No annotations, so the description carries the full burden, and it barely does. It never says this is a mutating operation, whether it requires an existing solved/connected model, whether it needs a named selection to exist, or what side effects adding a result has.

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?

Very short and front-loaded with the core action, so there is no filler to trim. But the terseness tips into under-specification: an 'Args:' list is not enough structure for a tool whose schema documents nothing.

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 explained. Even so, for a mutation tool with zero annotations and 0% schema coverage, the description omits prerequisites, side effects, and parameter meaning, leaving an agent without enough 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?

Schema description coverage is 0%, so the description is the only source of parameter meaning. It lists all three parameters and usefully supplies the X/Y/Z values for axis (the schema has no enum), but leaves named_selection and analysis_index completely unexplained beyond their 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?

States a specific verb (Add) and resource (Directional Deformation result), so the action is unambiguous. However, it does nothing to distinguish itself from close siblings like add_total_deformation, add_total_deformation_all_modes, or add_principal_stress, which also add result objects.

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 at all: nothing says when to pick directional deformation over total deformation or principal stress, nor any prerequisite (e.g., a solved analysis or active connection) needed before adding a result. The only hint is the axis enumeration, which is not 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 and largely fails: it does not say this is a mutating operation, whether it overwrites an existing displacement BC, what the units convention is, or what the agent needs beforehand (an existing named selection). The one genuine behavioral disclosure is that a None DOF is left unconstrained.

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?

Front-loaded with the purpose sentence, then a compact arg list; almost every token earns its place. The 'Args:' enumeration partially restates the schema fields, but the '(None=free)' annotation adds value the schema lacks.

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 5-parameter mutation tool with zero schema description coverage and no annotations the description is too thin — analysis_index semantics, units, and interaction with existing boundary conditions are all unaddressed.

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 all five arguments and clarifies that None leaves a DOF free, which is real added meaning over the raw anyOf/number-or-null schema. However, it leaves analysis_index (an integer defaulting to 0) completely unexplained and does not clarify what named_selection must reference.

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: 'Add Displacement BC', which is clearly distinguishable from siblings like add_remote_displacement, add_fixed_support, and add_frictionless_support. It is clear what the tool creates, though it never spells out that this is a boundary condition applied to a named selection.

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 statement of prerequisites, and no routing to alternatives such as add_remote_displacement or add_fixed_support. 'Pass None for a DOF to leave it free' is parameter guidance, not 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 behavioral burden. 'Add' implies mutation, but it does not disclose permissions needed, whether the result is persisted/reversible, or dependencies on a solved analysis. Only the named_selection scoping behavior is 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?

Two compact lines with the core action front-loaded and the Args broken out. Efficient and readable, with no wasted filler.

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, for a no-annotation mutation tool, the description leaves the analysis_index parameter and the operational prerequisites (valid selection, existing analysis) underexplained.

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 does clarify named_selection semantics (empty = whole model), which is valuable, but analysis_index is passed through with no explanation of what it selects or how it defaults.

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 (Equivalent/von Mises Stress result), which clearly differentiates it from the sibling add_principal_stress and add_stress_tool. Removal of ambiguity is good, though it does not explicitly name which sibling to prefer.

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?

Provides 'optionally scoped to a named selection' as context but never states when to use this vs add_principal_stress or the other stress tools, nor any prerequisites (e.g., whether an analysis must exist or be solved). No exclusions or alternatives are given.

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 largely fails. It does not disclose that this is a mutating boundary-condition action, whether a Mechanical connection/session is required, or how the named selection is resolved.

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?

Two short sentences with the purpose front-loaded and no wasted prose. The trailing 'Args:' list is largely redundant with the schema, but the overall structure is tight.

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 no annotations the description omits critical context such as prerequisites and the meaning of its inputs. It is too thin for an agent to invoke 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 restates the parameter names ('Args: named_selection, analysis_index') without adding meaning. It does not explain what a named selection is or what analysis_index selects, 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 (Add) and resource (Fixed Support) plus the target scope (a named selection), so an agent can tell it apart from most siblings. It does not explicitly distinguish itself from the closely related add_frictionless_support, but the resource name is 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?

There is no when-to-use guidance, no prerequisites, and no routing to alternatives like add_frictionless_support or add_displacement. The phrase 'to a named selection' gives application context but is not 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 behavioral burden. It discloses the unit (Newtons), which is genuinely useful, but says nothing about whether repeated calls accumulate, what coordinate system the vector acts in, what analysis_index selects, or whether a model must be connected first.

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 purpose sentence is front-loaded and tight, but the trailing 'Args:' list is pure duplication of the input schema and earns no place. The overall size is small, so it is not verbose, just partly redundant.

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. Still, for a 5-parameter mutation tool with zero schema coverage and no annotations, the description omits the direction convention for the force vector, the meaning of analysis_index, and the semantics of named_selection — gaps an agent cannot fill elsewhere.

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, yet it only restates the five parameter names that already appear as schema titles. The single added fact is the Newton unit for the force components; named_selection and analysis_index remain semantically opaque.

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 ('Add Force load in Newtons'), which is clear enough to distinguish it from most siblings like add_moment, add_pressure, or add_fixed_support. However, it does nothing to separate itself from the very close sibling add_remote_force, so an agent must still guess between the two.

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, and no mention of alternatives such as add_remote_force or add_moment. Usage is only implied by the name and the presence of a named_selection argument.

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 largely fails it. "Add" hints at a mutating operation that creates a new boundary condition, but nothing is said about side effects, whether it requires an active connection, whether it can be applied repeatedly, or how it interacts with existing supports.

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 short and front-loads the purpose, which is good. The trailing "Args:" clause is developer-facing filler that duplicates the schema and does not earn its place, but the overall text is not bloated.

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 the description still leaves the agent without any domain grounding for a specialized CAE boundary-condition tool. Nothing explains the required named_selection reference or the analysis_index target, which are essential to invoking 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, and it does not. "Args: named_selection, analysis_index" merely repeats the parameter names already visible in the schema, adding no meaning about what a named selection must reference or what analysis_index selects (or its default of 0).

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 Frictionless Support"), so an agent knows a boundary condition of that type is being created. However, it is essentially the tool name restated with no elaboration on what a frictionless support is or how it differs from siblings like add_fixed_support or add_displacement. Minimum viable, with no 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?

No when-to-use guidance, no prerequisites, and no mention of alternatives such as add_fixed_support or other boundary-condition tools. The agent is left to infer that this applies to a named selection in a mechanical analysis.

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 ('Add') and gives the moment units, but says nothing about what the load attaches to, permission/connection requirements, reversibility, or how it interacts with analysis_index. For a mutation tool with zero annotation coverage this is a substantial 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?

Very short and front-loaded with the core purpose, which is good. However, the second sentence is a raw 'Args:' list that adds no information beyond the schema, so the structure is efficient but not informative.

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 5-parameter mutation tool with no annotations and 0% schema coverage, the description omits the origin/prerequisites of named_selection, the role of analysis_index, and any behavioral context needed to call 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, and it only echoes the parameter names. The N·m unit implies mx/my/mz are moment components, but named_selection and analysis_index are left completely unexplained (what qualifies as a valid selection, what analysis_index selects). This is close to a bare parameter dump.

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 ('Add Moment load') plus the unit (N·m), which distinguishes it from sibling load tools like add_force, add_pressure, and add_standard_gravity. It does not explicitly name which siblings it is not, but the load type is clear enough to identify the 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 versus add_force or the other load-application siblings, nor any prerequisites (e.g., a connected model or an existing named selection). Usage must be entirely inferred 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?

Annotations are absent, so the description carries the full disclosure burden. It reveals units (Pascals) but nothing about mutation semantics, whether the named selection must already exist, which analysis the load attaches to, or what happens on repeated calls.

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 the important detail (unit) first, followed by a compact arg list. No filler, though the bare arg enumeration contributes little and could be trimmed.

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 this is a mutation tool with no annotations, zero schema coverage, and a required named_selection whose existence/validation requirements go unstated. The definition is too thin for an agent 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?

Schema description coverage is 0% across 3 parameters, so the description must compensate. It merely lists parameter names ('Args: named_selection, magnitude_pa, analysis_index') without explaining their meaning, format, or expected values, adding essentially nothing beyond the schema keys.

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 ('Add Pressure load') with the unit (Pascals), which cleanly separates it from sibling load tools like add_force, add_moment, or add_standard_gravity. It does not explicitly contrast with those siblings, keeping it just below 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?

No when-to-use guidance, no preconditions, and no alternatives named. An agent gets no help deciding between add_pressure, add_force, or add_remote_force.

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 this mutates the model tree, whether it requires a prior solved analysis, whether re-adding replaces or appends a result, or what analysis_index refers to. Only the bare 'add' semantics are conveyed.

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?

Two short sentences, front-loaded with the action, with no filler. It is efficiently structured, though the terseness borders on under-specification rather than true conciseness.

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 zero annotation coverage and 0% schema description coverage, the definition omits usage context, the meaning of analysis_index, and the behavioral effects of adding a result — gaps an agent cannot close from the structured fields.

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 usefully supplies the enum values max/mid/min for `which`, which the schema lacks, but leaves `analysis_index` completely unexplained beyond its name and default of 0.

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 Principal Stress result'), so the operation is unambiguous. It does not differentiate from close siblings such as add_stress_tool or add_equivalent_stress, which an agent would have to disambiguate by schema inspection.

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 add_stress_tool or add_equivalent_stress, nor any prerequisite (e.g. whether an analysis must exist or be solved first). The text only enumerates arguments, which is not 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?

With no annotations, the description carries the full behavioral burden, yet it discloses almost nothing: no precondition that a Mechanical connection and an existing named selection are required, no statement about which analysis the probe attaches to, and no indication of side effects. It only names the created object.

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?

Two short sentences, front-loaded with the core action. The 'Args:' fragment adds little beyond the schema, but the description is not bloated.

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 the definition omits the prerequisites and parameter meaning an agent needs to invoke it correctly. Given the sibling set implies a live Mechanical session, the missing connection/named-selection context is a 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?

Schema description coverage is 0%, so the description must compensate, but 'Args: named_selection, analysis_index' merely restates the parameter names. It never explains what analysis_index means (default 0) or that named_selection must reference an existing selection created via list_named_selections.

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: 'Add Force Reaction probe at a named selection.' This clearly distinguishes it from siblings that add stress, deformation, or boundary-condition objects. It stops short of explicitly contrasting with the closest alternatives, but the resource 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?

No when-to-use context, no prerequisites, and no mention of alternatives such as add_principal_stress or add_equivalent_stress. The agent must infer that this is an analysis-setup probe tool 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 behavioral burden. It discloses that omitting a DOF value leaves that DOF free, but says nothing about what gets created, whether existing boundary conditions are affected, selection requirements, or analysis_index 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 short and front-loads the core action before the parameter list. The 'Args:' line is somewhat redundant with the schema, but it is compact and easy to scan.

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 an 8-parameter mutation tool with no annotations and 0% schema description coverage, the description is incomplete. The output schema covers return values, but missing selection semantics, units, and when-to-use guidance leave important gaps.

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 lists all parameter names and adds the useful 'None frees a DOF' rule, but leaves named_selection, analysis_index, units, and coordinate conventions 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?

The description states a specific verb (add) and resource (Remote Displacement BC), so an agent can understand the basic operation. It does not distinguish this from the sibling add_displacement, but the 'Remote' qualifier makes the purpose reasonably 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?

The description gives no guidance on when to use this tool versus add_displacement, add_fixed_support, or other boundary-condition siblings. The only usage note, 'Pass None for a DOF to leave it free,' is a parameter behavior rather than tool-selection 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 for a mutation tool. It never says what the load is applied to, whether it is reversible or how to remove it, what permissions or model state are required, or whether the call mutates the active analysis — a substantial gap for a write 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?

The definition is short and front-loaded, which is good, but the 'Args:' list consumes the entire body while adding nothing the schema does not already show. Half the text is dead weight.

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 the definition omits the semantics of units, the meaning of analysis_index, requirements on the named selection, and how this tool relates to add_force and the other load-creation siblings. For a 5-parameter mutation tool with zero annotation and zero schema-description coverage, this is not enough to call 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 for five undocumented parameters. It merely repeats the parameter names verbatim; it does not explain that fx_n/fy_n/fz_n are force components (presumably in Newtons, implied only by the '_n' suffix) or what analysis_index selects.

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 ('Add Remote Force load'), so an agent knows it creates a remote force load. However, it does nothing to distinguish itself from siblings like add_force, add_reaction_force, or add_remote_displacement, leaving the choice between force variants to inference.

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, no mention of prerequisites (an existing named selection, an active analysis), and no reference to alternative force tools. The only content beyond the title sentence is a bare list of argument names, which is not 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?

With no annotations, the description carries the full behavioral burden, yet only notes the default direction (-Y) and the unit-vector semantics. It says nothing about whether gravity is additive, requires an existing analysis, permissions, or what happens on repeat calls. The default direction is also already visible in the schema.

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?

Two short sentences, front-loaded with the purpose before the argument list. The 'Args:' enumeration is slightly redundant against the schema but keeps it readable and wastes little space.

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 the unit-vector note is helpful. But for a mutation tool with zero annotations and four undocumented parameters, the description is thin on behavioral and parameter 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%, so the description must compensate, and it partially does by listing the four args and clarifying that x/y/z form a unit direction vector. However, analysis_index is left entirely unexplained, so the compensation is incomplete.

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: 'Add Standard Earth Gravity', which is clearly distinct from sibling load tools like add_force or add_moment. It is clear and unambiguous, though it never explicitly contrasts itself against 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?

There is no statement of when to use this tool versus alternatives, prerequisites (e.g. an existing analysis), or when not to use it. The only implied usage comes from the name itself, and no routing guidance is offered.

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 disclosure burden. It implies a dependency on existing material definitions, but says nothing about whether the analysis must be solved first, whether the tool mutates results or only adds a result object, or 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?

Two short sentences, front-loaded with purpose, so there is no padding. However, the trailing 'Args: analysis_index' line consumes space without conveying any information beyond the schema's own property name.

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 tool in a simulation workflow with zero annotations, one fully undocumented parameter, and undocumented prerequisites, the description is too thin to let an agent call it correctly without trial and error.

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 parameter is undocumented in the schema (0% coverage), so the description must compensate. 'Args: analysis_index' merely restates the parameter name without explaining what an analysis index refers to, what the default 0 selects, or how to obtain a valid value.

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 ('Add Stress Tool') and, unusually for this family, names the outputs it computes ('safety factor, stress ratio') plus the basis ('material limits'), which distinguishes it from sibling result tools like add_principal_stress and add_equivalent_stress. The term 'Stress Tool' itself is product jargon, but the parenthetical carries the meaning.

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 mention of prerequisites (e.g., that a solved analysis and assigned materials are needed), and no routing to alternatives such as add_principal_stress or add_equivalent_stress. The clause 'using material limits' hints at a precondition but 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, and it discloses almost nothing: not whether an analysis must be solved first, not what the result attaches to, not what happens on repeat calls, and not the effect of the 'mode' flag beyond 'not modal'.

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?

Two short clauses with the core action front-loaded and no filler. The trailing args list is efficiently structured, though the overall brevity reflects under-specification as much as 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?

An output schema exists, so return values need not be explained, but for a mutation tool with no annotations, 0% schema coverage, and a near-identical sibling, the description is too thin to let an agent invoke it confidently or pick it over the alternatives.

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 partially explains 'mode (0=not modal)' but gives no meaning for 'analysis_index' (base, indexing scheme, or what it selects), leaving one of two parameters completely 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?

Specific verb and resource: 'Add Total Deformation result' tells the agent it creates a result object of that type. However, it never distinguishes itself from the sibling add_total_deformation_all_modes, which an agent could easily confuse it with; only the parenthetical 'mode (0=not modal)' hints at the single-vs-all-modes difference.

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 statement of when to use this tool versus add_total_deformation_all_modes, add_directional_deformation, or the other result-adding siblings. The only context is the terse '0=not modal' note, which is a parameter value, not 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 behavioral burden, and it discloses almost nothing. It does not state that this mutates the model/result tree, whether it requires an active Mechanical connection, whether it needs a completed modal analysis first, or whether repeated calls are idempotent.

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?

Two short sentences with the core action front-loaded and no filler. The trailing 'Args:' list merely repeats schema keys, which is minor waste, but the description is otherwise tight.

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 mutating tool with zero annotations and zero parameter documentation the description is not complete enough. It omits prerequisites, the effect of the defaults (6 modes, analysis index 0), and how it relates to sibling result 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, but it only echoes the parameter names ('Args: num_modes, analysis_index') with no meaning attached. It does not explain that num_modes controls how many modal modes are rendered or what analysis_index selects, leaving both parameters semantically opaque.

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 ('Add Total Deformation') and scopes it to 'all modal modes', which distinguishes it from the sibling 'add_total_deformation' (presumably a single mode/scope) and from 'add_directional_deformation'. It never names or contrasts with those siblings explicitly, so it lands at 4 rather than 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?

No when-to-use guidance is given. The agent cannot tell from the text whether to prefer this over add_total_deformation, add_directional_deformation, or add_equivalent_stress, nor what prerequisite state (connected model, completed modal solve) is required.

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 disclose whether the operation overwrites an existing material assignment, what permissions are needed, or any side effects of the mutation.

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?

It is appropriately short and front-loads the purpose, but the 'Args: body_name, material_name' line is pure duplication of the schema and consumes half the text without adding information.

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, and the core intent is conveyed. Still, as an annotation-free mutation tool it omits mutation semantics and the logical prerequisite of an existing material.

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, but it only repeats the two parameter names verbatim. No format, source, or existence requirement is explained for body_name or material_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+resource combination ('Assign material to a body') that an agent can distinguish from sibling tools like list_materials. However, it offers no differentiation about when this is appropriate relative to other material/setup operations.

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, no alternatives. It does not tell the agent that the material likely must already exist (list_materials) or that the body must exist before assignment.

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 it only restates the name. It does not disclose what states are reported, whether a failed connection is an error or a returned status, or any latency/side-effect profile for a status probe.

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 short sentence, appropriately sized for a zero-argument status probe with no wasted wording. It is terse rather than padded, though the brevity borders on under-specification.

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 simple, parameterless status check with an output schema present, the description is close to complete — return values are documented by the schema, so it need not restate them. The only gap is the absence of any hint about connection semantics or failure modes.

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 beyond the schema. Baseline 4 applies for a parameterless tool.

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 (check) and resource (connection status), which is distinguishable from the connect/disconnect siblings at a glance. However, it doesn't explicitly say what 'connection' means here (e.g., the link to the Ansys Mechanical solver session) or name the sibling tools it complements.

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 connect_to_mechanical or disconnect_from_mechanical. There is no mention of prerequisites, such as whether a session must already be established for the check to be meaningful.

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 is thin. It does disclose one useful behavioral fact — the port changes every session — but says nothing about session lifecycle, whether an existing connection is replaced, authentication, or failure modes for a stateful connection 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?

Two short lines, front-loaded with the action; no filler. The 'Args:' block is slightly schema-like boilerplate but carries real information about the port.

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 an output schema present, return values need not be explained, and the single parameter is covered. However, for a session-establishing tool with no annotations, the description lacks prerequisites and its relationship to the connection-checking and disconnect siblings.

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%, so the description must compensate, and it largely does: it identifies 'port' as the gRPC port reported by Workbench and warns that it changes every session, which is exactly the semantics an agent needs. It omits format/range detail, keeping it from a 5.

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: 'Connect to ANSYS Mechanical via gRPC.' An agent can tell this is a connection-establishment tool. It does not explicitly differentiate itself from the sibling 'check_mechanical_connection' or 'disconnect_from_mechanical', so it stops 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 never says when to use this versus check_mechanical_connection or disconnect_from_mechanical, nor any precondition (e.g., Workbench must be running, must already be unconnected). Usage must be inferred 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?

With no annotations, the description carries the full burden. It usefully discloses that only unsuppressed bodies are affected, that conversion is 'combined' into a single point mass, that a Named Selection is created as a side effect, and that no ACT extensions are needed. However, it omits whether the original bodies are removed/replaced, whether the operation is reversible, and whether permissions are required.

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?

Two front-loaded sentences carry the core behavior, and the trailing Args line is compact. The Args line is partly redundant with the schema, which slightly dilutes the conciseness.

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. The description covers what happens at a high level, but for a non-annotated mutation tool it leaves key gaps: the fate of the original bodies, reversibility, and the meaning of proximity_multiplier.

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, but it only restates the argument names and the default already present in the schema. It never explains what part_name identifies (a named Part in the model tree?) or what proximity_multiplier actually controls (search radius for the nearest structural surface).

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 ('Convert all unsuppressed bodies inside a named Part to a combined Point Mass') plus a secondary effect (creating a Named Selection). It is clear what the tool does, but it does not differentiate itself from the similarly named sibling convert_prefix_to_point_mass, which an agent could easily confuse it with.

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 explains mechanics but gives no guidance on when to use this tool versus alternatives, and notably never addresses the nearly identical sibling convert_prefix_to_point_mass. There is no prerequisite, exclusion, or context statement.

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. It usefully discloses the compound side effect (also creates a Named Selection of coplanar attachment faces) and the 'No ACT extensions required' constraint, but says nothing about reversibility, what happens to pre-existing point masses, or failure/error conditions for a mutating 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?

Front-loaded with the core operation, followed by the resulting side effect, the ACT note, and a compact Args line. Efficient and well-ordered, though the trailing Args list partially restates the schema.

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 the compound behavior is outlined. Still, for a two-step mutating tool with zero annotation and zero schema coverage, the vague 'nearest structural surface' logic and the unexplained second parameter leave the agent under-equipped.

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%, so the description must compensate. It merely lists the argument names and the default 3.0, adding no meaning: 'proximity_multiplier' is left entirely unexplained (a multiplier of what, applied to which proximity?), leaving a cryptic parameter 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 precise verb ('Convert') and a clearly scoped resource (unsuppressed bodies whose name starts with a prefix), plus the compound result (combined Point Mass + Named Selection). It is distinguishable from the similar sibling convert_part_to_point_mass by its prefix-based bulk scope, though it never names that sibling 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 or when-not-to-use guidance. The prefix-matching scope is stated, but nothing tells the agent when this batch tool should be chosen over convert_part_to_point_mass or the other point-mass 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. "Delete" implies a destructive mutation, but the description never says whether the deletion is permanent, what happens to downstream references to the selection, or what errors occur for a missing 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 short and front-loads the action, which is good, but the trailing "Args: name" is pure filler that duplicates the input schema and earns no place in the 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?

An output schema exists, so return values need not be explained. However, for a destructive tool with zero annotations and zero schema coverage, the description omits the safety and failure-mode context 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% and there is one required parameter, yet "Args: name" only restates the parameter's identifier. It adds no meaning such as whether the name is case-sensitive, unique, or must match an existing selection.

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 ("Delete a named selection"), which is enough for an agent to distinguish it from siblings like list_named_selections or suppress_bodies. It does not, however, explicitly contrast itself with alternatives, so it stops 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 guidance on when to use this versus other tools, no prerequisite (e.g., the selection must already exist), and no warning that the operation is irreversible. The only usage information is the redundant "by name" phrase.

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 does well: it discloses that the default is non-destructive (session stays alive) and that shutdown=True closes Mechanical with loss of unsaved work. That destructive side-effect warning is exactly what an agent needs, though it doesn't cover reversibility or auth requirements.

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 primary action and its default scope are front-loaded in the first clause, with parameter detail following. It is compact and waste-free, though the inline 'Args:' formatting is slightly less scannable than a clean 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?

This is a simple one-parameter tool with an output schema, so return values need no explanation. Purpose, default behavior, and the destructive effect of the optional flag are all present; only permission/auth context for a session-ending operation is 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%, so the description must compensate for the lone 'shutdown' parameter, and it does: it explains that True closes Mechanical itself and loses unsaved work. The schema supplies default=false, and 'leaving the session running' confirms the default semantics, so meaning is fully conveyed.

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 ('Disconnect from Mechanical') with the crucial scope qualifier that the session keeps running by default. This cleanly separates it from connect_to_mechanical and check_mechanical_connection without needing to inspect any 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?

The description implies the disconnect scenario and clarifies default behavior (session left running), but never explicitly states when to use this versus checking the connection or simply ending work. No exclusions or prerequisites are given, so guidance is inferred rather than 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, the description carries the full burden. It adds one behavioral fact ('Visible live in Mechanical GUI'), which is genuinely useful, but says nothing about whether the tool requires an active Mechanical connection, whether it blocks until meshing completes, or what happens on mesh failure.

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?

Two short sentences with the action front-loaded and no filler. The brevity is close to under-specification rather than tightness, but nothing is wasted.

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 a zero-parameter tool needs little argument detail. However, for a GUI-driving action inside a connected workflow, the missing prerequisites and blocking behavior leave a 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 are no parameter semantics to document and the baseline is 4. Nothing in the description misrepresents the argument surface.

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 ('Generate mesh'), which is clearly distinguishable from the read/inspect siblings get_mesh_statistics and set_mesh_element_size. It does not explicitly name or contrast those siblings, 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?

There is no when-to-use guidance, no stated prerequisites, and no mention of alternatives. Given the sibling set includes connect_to_mechanical, assign_material, and solve_analysis, an agent must guess whether a connection or material assignment must precede meshing.

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 almost nothing: it does not say whether an existing file at output_path is overwritten, whether the analysis must be solved first, or whether the tool blocks/fails on bad input. Listing the arg names is not behavioral disclosure.

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 plus an arg list, with the purpose front-loaded and no filler. The 'Args:' fragment is terse to the point of under-specification rather than verbose, so brevity is not the problem here.

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 3-parameter tool with zero annotations and 0% schema coverage, this description leaves too much unspecified: overwrite behavior, prerequisites (a solved analysis), and analysis_index meaning are all absent. An output schema exists, so return values need not be explained, but the invocation-side gaps remain.

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 does add genuine value by enumerating the fmt values ('docx or txt'), which the schema does not (no enum present). However, analysis_index is unexplained (which analysis? what does the default 0 select?) and output_path's required format/extension expectations are not stated.

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 clear verb+resource ('Generate simulation report'), which no sibling tool duplicates — the sibling list contains only model/mesh/BC/solve operations. It does not need sibling differentiation here, but it also does not mention scope (single analysis vs whole model), leaving one gap.

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 at all — nothing says this should be called after solve_analysis, nor whether it is restricted to a completed/solved analysis. No exclusions or alternatives are named, so the agent must infer usage from context 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. It's a read operation implied by 'Get,' and it specifies the exact return contents (node and element counts), which is useful. However, it doesn't disclose whether this requires a pre-existing mesh, whether it triggers computation, or any performance/state considerations.

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 that front-loads the action and resource. 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?

With an output schema present, the description needn't explain return values in detail. However, for a tool with no annotations and no parameters, it lacks behavioral context like prerequisites (e.g., mesh must exist) or state implications that an agent would need 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?

Parameter count is 0, so the baseline is 4. The description doesn't need to explain parameters since none exist, and it doesn't introduce confusion about them.

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 (Get) and resource (mesh statistics), and specifies what statistics means (node and element counts). This distinguishes it from siblings like get_model_info, though it doesn't explicitly name alternatives.

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 like get_model_info or after generate_mesh. The context of mesh-related tools implies usage, but nothing is stated explicitly.

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 does disclose notable behavior: frequencies are only readable through result objects, and add_results_if_missing is a side-effecting write that creates and evaluates Total Deformation results. It also documents the misleading legacy empty-list-with-ok:true behavior. Missing permission/auth context, but that is minor here.

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?

Front-loaded with the core purpose, then the result-object constraint, then the Args note. The historical aside about the old empty-list behavior is slightly verbose but earns its place by justifying the flag, and nothing is redundant.

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 explained, and the side effect of the default-true flag is covered. However the analysis_index parameter is left unexplained and there is no guidance on prerequisites, leaving the two-param tool only partially specified.

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%, so the description must compensate. It fully explains add_results_if_missing (adds Total Deformation results and evaluates them when none exist) but only names analysis_index without saying what it indexes or how analyses are numbered, leaving half the parameters under-specified.

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 ('Get') and resource ('natural frequencies from a modal analysis'), which is unambiguous and distinct from siblings like add_total_deformation_all_modes or solve_analysis. It does not explicitly name an alternative, but no sibling competes for this purpose.

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?

It implies context by explaining that frequencies are only readable through result objects and that the flag auto-adds results when none exist, which tells the agent when the flag matters. However, it never states when to call this versus the sibling result-creation tools, nor any preconditions such as requiring a solved analysis.

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 nothing about read-only safety, required connection state, or permissions. Since it is a zero-parameter read tool with an output schema, the omission is less costly, but the description adds no behavioral context at all.

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 key categories listed immediately after the colon; nothing is wasted. It is arguably too terse to be fully helpful, but strictly on conciseness it is 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?

For a zero-param read tool with an output schema present, the description is minimally adequate: return values need not be explained, but with no annotations the safety profile and connection prerequisites remain undisclosed. Left a gap an agent would want closed before invoking.

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 beyond the schema. 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 clear verb (Get) and resource (model info) and enumerates the returned categories (bodies, named selections, analyses). It is distinguishable from sibling mutators, though it overlaps with list_named_selections and list_materials without explaining the difference.

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 alternatives such as list_named_selections, list_materials, or get_mesh_statistics. The agent must infer its role as a general model-state inspection 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. It does not state whether this is a read-only poll, whether it blocks, what happens if the analysis hasn't been solved, or anything about the returned status values.

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?

Extremely short and front-loaded, which is good, but the terseness comes at the cost of usefulness. 'Args: analysis_index' is a schema echo rather than meaningful 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?

With an output schema present the return values needn't be described, but for a status-query tool in a mechanical analysis workflow the agent still needs to know when the status is meaningful and what the index selects. None of that is covered.

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 only parameter, analysis_index, is not explained (no meaning, no valid range, no default rationale). The description merely repeats the arg name ('Args: analysis_index'), adding no semantic value.

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 verb+resource ('Get solve status') but is vague about what 'solve status' actually returns and does not differentiate from siblings like solve_analysis or get_mesh_statistics. An agent can infer it relates to a solve, but the description gives no scope detail.

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 or alternatives. In a sibling set with solve_analysis and get_model_info, it's unclear whether this should be called before, after, or instead of those 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 behavioral burden. 'List' implies a safe read, but nothing is said about scope, whether results are tied to a specific analysis, ordering, or grouping. The only behavior disclosed is the bare fact of enumeration.

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?

Very short and front-loaded, so nothing is padded, but the 'Args: analysis_index' fragment adds no information and reads as under-specification rather than economy. The single useful sentence is doing little work.

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 the return shape, so that need is met. But with an undocumented parameter, no annotations, and no explanation of what this tool lists relative to the many add_*/list_* siblings, the definition is not complete enough for confident invocation.

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 analysis_index — but it only restates the parameter name as 'Args: analysis_index'. It does not say which analysis the index refers to, whether it is required despite defaulting to 0, or what happens with an invalid index.

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: 'List all boundary conditions'. An agent can tell this is a read/enumeration tool. However, it offers no differentiation from sibling list tools (list_named_selections, list_point_masses, list_materials) about what 'boundary conditions' covers in this 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 when-to-use guidance, no prerequisites, and no mention of alternatives. The agent must infer that it should call this to discover existing boundary conditions before adding supports/forces, which is plausible but unstated.

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 implies a read-only operation through "List," but does not state permissions, side effects, or any other behavioral context beyond the resource scope.

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 states the action, resource, and scope with no wasted words. Its size is appropriate for a no-argument listing 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?

For a simple, parameterless list tool with an output schema, the description is largely complete enough to invoke correctly. It states what is listed and where, though it lacks behavioral or usage context that could help in ambiguous situations.

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 there are no parameter semantics to document in the description. The empty input schema is self-explanatory, and the baseline score for a parameterless tool is 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 gives a specific verb ("List") and resource ("materials") plus a clear domain scope ("in Engineering Data"). It does not explicitly distinguish itself from sibling list tools or mention assign_material, but the purpose is still 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 guidance on when to use this tool versus alternatives such as assign_material or other list_* tools. Usage is only implicit from the verb "List" and the resource 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, and it delivers almost nothing beyond the return contents. It does not state that this is a safe read-only operation, whether a model/connection must already be open, or whether an empty list is returned when no selections exist.

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 return contents are mentioned immediately. It is efficient, though brief enough that it omits context a lone sentence could easily have carried.

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 a zero-parameter signature and an output schema present, the return values do not need explaining, so the description is close to adequate for a simple listing tool. The missing pieces are behavioral: no annotation coverage means the read-only nature and any connection prerequisite go entirely unstated.

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, which is the stated baseline of 4. The description correctly implies a no-argument listing operation with nothing to configure.

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 all named selections') and even names the payload ('face/body counts'), so an agent knows exactly what it gets. It does not, however, differentiate itself from the other 'list_*' siblings (list_materials, list_point_masses, list_boundary_conditions), though the resource noun 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 guidance on when to call this versus alternatives, nor any prerequisite such as needing an active Mechanical connection. The only implied usage is the verb 'List' itself, which is minimal.

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. 'List all' implies a safe read and it discloses the returned fields, but it says nothing about scope (active model only?), permissions, pagination, or confirm that the call is non-mutating. The field enumeration partly duplicates what the output schema already carries.

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. Minor cost: jargon and abbreviations ('CG', 'pinball', 'scoped named selection') are compressed into a list that may be opaque without domain knowledge.

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-param list tool with an output schema, the description covers what the call returns conceptually without needing to restate the schema. The only real gap is that no safety/auth behavior is stated, though 'List all' is an unambiguous read.

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 to document and the baseline is 4. The description correctly does not invent parameter guidance.

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 ('List') and resource ('Point Masses') and enumerates the returned attributes (CG, mass, pinball, scoped named selection). It does not name or distinguish itself from near-neighbours like convert_prefix_to_point_mass or convert_part_to_point_mass, but the verb alone makes the read-vs-create distinction 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?

There is no explicit when-to-use statement or named alternative, but for a zero-parameter enumeration tool the usage ('list all point masses') is implied directly by the verb and resource. No exclusions or preconditions are offered.

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 and no output/behavior notes, the description carries the full burden and mostly fails it. Executing arbitrary Python inside a CAE session is highly consequential — the description should disclose sandboxing, side effects on the model, required connection state, and error behavior. Only the phrase 'inside Mechanical ACT API' hints at execution 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?

Front-loaded and very short, which is a virtue, but the trailing 'Args: script' fragment duplicates the parameter name and earns no space. Appropriate brevity tips into under-specification for an arbitrary-code-execution 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 explained here. But for a tool that runs arbitrary code against a live simulation model, the description omits execution environment, side effects, and any connection prerequisite — too thin given the tool's risk profile.

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 the single parameter has no description in the schema. The description's 'Args: script' merely restates the parameter name; the only real semantic added is that the string is Python source for the ACT API, with no syntax, entry-point, or expected-form guidance.

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 — running a custom Python script — and names the execution context (Mechanical ACT API), which separates it from the domain-specific siblings like add_force or generate_mesh. It stops short of contrasting itself with those siblings explicitly, 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 guidance on when to reach for this tool versus the dozens of purpose-built siblings (add_fixed_support, set_mesh_element_size, etc.). No prerequisites, no indication of what the script can or cannot touch, and no 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 provided, so the description carries the full behavioral burden. It discloses that the setting is global rather than local, but says nothing about whether this invalidates an existing mesh, requires regeneration, persists across sessions, or what permissions/state are needed for a mutation.

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 front-loaded sentence plus a redundant 'Args: element_size_mm' trailer that merely restates the parameter name. Efficient overall, with only minor waste.

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. For a mutation tool with no annotations and an undocumented parameter, the definition covers the essential 'what and unit' but omits sequencing with generate_mesh and any state effects, leaving meaningful gaps.

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 the single parameter has no description, so the description's 'in mm' unit note is genuinely additive. However, it adds no range, validity constraints, or default behavior beyond the unit, leaving the parameter only partially characterized.

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 (Set) and resource (global mesh element size) with the unit (mm), which is enough to distinguish it from siblings like generate_mesh or get_mesh_statistics. It does not explicitly name an alternative, but the resource is specific enough that confusion is unlikely.

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, whether it must precede generate_mesh, or how it interacts with existing mesh state. The likely ordering relative to generate_mesh is left 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?

With no annotations, the description carries the full burden. It usefully discloses that progress is visible in the GUI, that solver messages are returned, and that wait=False makes the call asynchronous requiring polling. It says nothing about failure behavior, blocking, or resource/prerequisite constraints, so meaningful gaps remain for a long-running solver invocation.

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?

Three short sentences, purpose front-loaded, with the critical async caveat folded onto the parameter. The 'Args:' line is cramped but earns its space; only minor tidying is possible without losing 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?

An output schema exists, so return values need no explanation, and the async/timeout mechanics are covered. However, for a mutation-style solve operation with no annotations, the description omits prerequisites, likely failure modes, and whether the solve is cancelable or blocking — gaps an agent would want 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 two parameters, so the description must compensate. It explains wait well (False submits and returns at once), adding real meaning beyond the bare boolean, and names analysis_index but never clarifies what the index refers to or how it maps to project analyses.

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 ('Solve') and resource ('the analysis'), which is enough to distinguish it from the numerous setup tools (add_force, generate_mesh, etc.) in the sibling list. It does not explicitly name a contrasting sibling, but the scope is unambiguous for an FEA workflow.

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?

It gives a real when-to-use rule for the wait parameter: use wait=False for solves longer than the client call timeout, and then poll get_solve_status. This names the alternative tool and the condition that selects it, though it offers no guidance on prerequisites (mesh/BC readiness) or when not to solve.

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 discloses that an empty name prefix targets all bodies and that suppress=True/False controls the direction, but it does not describe reversibility, side effects on analysis, or required model state.

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 two concise sentences with no wasted text. The core operation is front-loaded, and the parameter notes are appended efficiently.

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 simple two-parameter toggle with an output schema, the description covers the operation and both parameters adequately. It omits some domain side effects, such as how suppression affects downstream analysis, but the output schema handles 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. It explains both parameters: suppress as a boolean with True=suppress and False=unsuppress, and name_prefix as a prefix filter where empty means all bodies. It does not specify prefix matching rules such as case sensitivity.

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: suppress or unsuppress bodies by name prefix. It clearly distinguishes this operation from sibling tools such as add_* and solve_analysis, so an agent can identify its purpose immediately.

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 explains what the tool does but gives no guidance on when to use it versus alternatives, nor any prerequisites. There is no explicit when-to-use or when-not-to-use context.

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