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

The description explicitly labels the tool as '[READ ONLY]', which is a useful behavioral disclosure given that no annotations were provided. Beyond that, it does not describe what the audit checks, what side effects (if any) occur, or what outcome the caller should expect, so behavioral transparency remains limited.

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

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

The description is short and front-loads the read-only intent. It contains no filler, but it is so brief that it leans toward under-specification, so it does not earn a 5.

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

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

With no annotations and no parameter guidance, the description leaves important gaps: what 'audit' verifies, whether the project must be open, and what kind of output an agent should expect. The existence of an output schema helps but does not make the description complete.

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

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

Schema description coverage is 0%, and the description does not explain either project_path or system_name beyond implying the system must already exist. The parameter names are somewhat self-explanatory, but the description adds little over the raw schema and does not compensate for the missing parameter documentation.

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

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

The description uses a clear verb ('Audit') and names the resource ('Mechanical system through its Workbench Model container'). However, it does not explain what 'audit' actually covers or how it differs from siblings like inspect_workbench_project or get_model_summary.

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

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

No guidance is provided about when to use this tool versus alternatives such as get_model_summary, get_messages, or inspect_workbench_project. The description does not mention preconditions, exclusions, or a preferred context, leaving the agent to infer usage.

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

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

With no annotations provided, the description carries the disclosure burden and does so by explicitly labeling the operation '[READ ONLY]', signaling no model mutation. It also notes the capture is of the 'current' view, implying dependance on the present display state; it does not discuss file overwrite or output details, but the output schema and filename default mitigate that 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?

The description is a single front-loaded sentence with zero filler; the '[READ ONLY]' safety signal comes first)Skip... The whole text earns its place and communicates the essential purpose immediately.

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 one-parameter tool with an output schema and a sensible default filename, the description is nearly complete. It covers the operation's purpose and read-only nature, and the missing details about saved file location are minor given the schema and default value.

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%, yet the description adds no explanation of the 'filename' parameter or how it affects the capture. The property name and default value provide the only semantics, so the description fails to compensate for the schema's missing description, even though the parameter is optional and self-explanatory.

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 uses a specific action verb ('Capture') and names a concrete resource ('current Mechanical graphics view'), making the tool's function unambiguous. It also differentiates itself from the sibling get_* data-retrieval tools by being the only image-capture operation.

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

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

The phrase 'Capture the current Mechanical graphics view' clearly indicates when this tool is appropriate: whenever a snapshot of the current display is needed. It does not explicitly name alternatives or exclusions, but the intended context is clear enough and no sibling tool competes for this exact purpose.

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. The '[READ ONLY]' prefix is a useful behavioral disclosure indicating no modifications. However, it does not explain connection state, whether the call is idempotent, what happens if the server is not running, or whether it must precede other tools.

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

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

The description is one short sentence with no filler. The read-only trait is front-loaded and the rest directly states the operation and target. Every word earns its place.

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

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

For a zero-argument connection tool with an output schema, the description is nearly sufficient. It could benefit from a note about when to connect relative to sibling tools, but the core purpose and safety trait are 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?

With zero parameters and 100% schema coverage, there is nothing for the description to add about arguments. The baseline for a zero-parameter tool is 4, and the description does not introduce any confusion about inputs.

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

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

The description states a specific verb ('Connect') and a specific resource ('configured local Mechanical server'), making its purpose immediately obvious. It is clearly distinguishable from siblings like get_project_info or solve_analysis, which are read/inspection or modification 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 guidance is given about when to use this tool, such as 'call before other Mechanical operations' or 'only needed once per session.' Since siblings include mechanical_status and open_project, the agent gets no help choosing between them or knowing whether to connect first.

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

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

The [MODIFIES MODEL] prefix discloses that the tool mutates the model, which is important since annotations are absent. However, it does not explain whether existing selections are overwritten, what permissions are needed, or any other side effects, leaving significant gaps.

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

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

The description is a single concise sentence with no fluff, and the [MODIFIES MODEL] tag is front-loaded. However, it is so brief that it sacrifices necessary detail, making it efficient but under-specified.

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

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

Given no annotations, no schema descriptions, and an output schema whose contents are unknown, the description is insufficient for correct invocation. It lacks parameter definitions, behavioral details, and any guidance on model state or error handling.

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 both parameters. It clarifies 'entity_ids' as IDs of geometry entities, but the 'name' parameter is not explained at all. The description only partially compensates for the missing schema.

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

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

The description clearly states the action (create), the resource (geometry named selection), and the input (entity IDs). It is specific and distinct from the sibling get_named_selections, which reads selections.

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 when to use this tool (for creating selections) but does not explicitly mention alternatives or when not to use it. No exclusions or prerequisites are stated, leaving some inference 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?

The description explicitly includes '[MODIFIES MODEL]', which discloses a mutating behavior that would otherwise be invisible without annotations. However, it does not say what exactly changes, whether existing results are overwritten, or whether a solved analysis must already exist, so the behavioral disclosure is only partial.

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

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

The description is a single short sentence with the mutation warning front-loaded, making it efficient and scannable. It could reach 5 by adding a brief clarification of what 'evaluate' entails without becoming 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?

For a one-parameter tool with an output schema, this is minimally usable: it identifies the target, warns about mutation, and the output schema covers return values. But the vague meaning of 'evaluate', missing prerequisites, and lack of distinction from solve_analysis leave important context incomplete.

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

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

Schema description coverage is 0%, and the description provides no additional meaning for the analysis_name parameter. The phrase 'in an analysis' only weakly maps to the parameter, adding little beyond the schema property title 'Analysis 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?

The description states a clear action ('evaluate') and a clear resource ('all existing results in an analysis'), so an agent can identify what the tool operates on. However, 'evaluate' is somewhat generic and it does not distinguish this tool from siblings such as solve_analysis or get_result_summary.

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 about when to use this tool, what prerequisites must be met, or how it differs from sibling tools. The agent is left to infer the appropriate context from the tool 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?

The description includes the '[MODIFIES MODEL]' tag, which signals mutation, but with no annotations the description carries the full burden. It does not disclose whether an existing mesh is overwritten, whether the operation is reversible, or what side effects may occur.

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 very short and front-loads the key mutation signal before the action statement. It is appropriately sized for a tool with no parameters, though it could still include a little more context without becoming 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?

Even though an output schema existsched, the description is incomplete for a model-modifying operation. It omits prerequisites, the exact effect on existing mesh data, and any cautionary context, which an agent would need to invoke and interpret this tool safely.

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

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

The input schema has zero parametersholistic, so there are no parameter semantics for the description to clarify. The baseline of 4 for zero-parameter tools 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?

The description states a clear verb ('Generate') and resource ('the Mechanical mesh'), so an agent knows the core action. It does not, however, distinguish this from related sibling tools such as get_mesh_statistics or set_mesh_size.

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 about when to run mesh generation, what prerequisites are needed (e.g., geometry must exist), or when to prefer a sibling tool such as get_mesh_statistics instead. The usage context is entirely absent.

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

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

The '[READ ONLY]' tag tells the agent this is a non-mutating inspection, which is useful because no annotations are provided. However, the description does not disclose required model state, potential failure modes, or why this tool specifically returns boundary-condition data. It partially carries the behavioral burden but leaves significant gaps.

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 very short, front-loads the read-only qualifier, and contains no filler. It is efficient as a minimal label, though it sacrifices specificity in doing so.

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

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

With no parameters and an output schema, invocation is simple, but tool selection among 27 siblings is underspecified. The phrase 'Mechanical model data' could describe nearly every get_* sibling, and the actual boundary-condition scope is only implied by the tool name. An agent cannot confidently choose this tool over alternatives from the description alone.

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?

This tool has zero parameterscars, and the schema already documents this completely. There is no parameter-level meaning for the description to add, so the absence of parameter detail 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 states a read-only inspection action, but only broadly targets 'Mechanical model data' rather than boundary conditions specifically. It does not distinguish this tool from siblings like get_connections or get_model_summary. It is not a tautology, but it is too vague for the named resource.

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

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

No guidance is given on when to use this tool versus get_model_summary, get_connections, get_material_assignments, or other siblings. The only usage hint is the read-only qualifier, which applies to many similar tools. There are no exclusions, prerequisites, or alternative routing clues.

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

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

The description opens with '[READ ONLY],' which is a useful behavioral disclosure since no annotations are provided. It makes clear the tool is non-mutating, but it does not add further behavioral context such as what kinds of connections are returned or whether it operates on the currently active model. The output schema likely covers return structure, so this is adequate but minimal.

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

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

The description is extremely short and front-loads the read-only nature of the tool. There is no wasted text, though the wording is so generic that it sacrifices clarity. Still, as far as length and structure go, 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-parameter read tool with an output schema, the description does not need to explain return values, but it still fails to give enough context to select it among many similar getters. 'Inspect Mechanical model data' is too generic to tell the agent that this tool is specifically about connections, especially with siblings like get_model_summary and get_geometry_bodies present.

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

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

The tool has zero parameters and the schema description coverage is 100%, so there is no parameter information missing. The description does not need to add semantics for parameters that do not exist, and the baseline for no parameters is 4.

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

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

The description says 'Inspect Mechanical model data,' which is vague and does not mention 'connections' at all. It uses a generic verb and an overly broad resource, so an agent cannot tell that this tool returns connection-related data rather than general model data. It does not distinguish itself from siblings like get_model_summary or get_tree.

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 about when to use this tool versus any of the many sibling inspection tools. The phrase 'Inspect Mechanical model data' implies a read operation but provides no context, exclusions, or alternatives.

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

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

The description only says 'Inspect Mechanical model data,' which is minimal. It does not disclose what kind of data is returned, whether it reflects the current state of the model, or any side effects. Since no annotations are provided, the description carries the full burden, and it does not add meaningful behavioral context beyond the read-only hint.

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 extremely short and front-loaded with the read-only hint. It is concise, but it is so brief that it sacrifices useful context. Still, for a no-parameter tool, brevity is acceptable.

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

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

Given the tool has an output schema, the return structure may be documented there, but the description does not explain what 'geometry bodies' are, how they relate to the model, or when to call this tool. Among many sibling inspection tools, this description is too thin to guide an agent effectively.

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 is no parameter semantics burden. The description correctly implies that no input is needed, and the schema confirms this. Baseline 4 is appropriate for a no-parameter 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?

The description states a verb ('Inspect') and a resource ('Mechanical model data'), but it is vague about what 'geometry bodies' specifically means and how it differs from sibling tools like get_model_summary or get_tree. It is not a tautology, but it lacks the specificity needed to distinguish it from other inspection tools.

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

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

No guidance is provided about when to use this tool versus alternatives. The '[READ ONLY]' prefix implies it is safe to call, but there is no mention of prerequisites (e.g., must have a model open) or when to prefer get_model_summary or get_tree instead.

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

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

The description explicitly labels the operation as '[READ ONLY]' and uses 'Inspect,' which communicates non-mutating behavior. This is useful because annotations are absent, though it does not disclose any further behavioral details or edge conditions.

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

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

The description is a single concise sentence with the read-only hint front-loaded. However, the wording is generic enough that it could describe almost any inspection tool, so brevity sacrifices specificity.

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 zero parameters and an output schema present, invocation complexity is lowched. Still, the description does not explain what material assignments are or when to prefer this over similar inspection tools, leaving an incomplete picture for a sibling-rich 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?

This tool has no parameters, so schema coverage is trivially 100% and no parameter documentation is needed. The description correctly avoids inventing nonexistent inputs.

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

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

The description says 'Inspect Mechanical model data,' which is broad and does not explicitly mention material assignments. This does not distinguish the tool from siblings like get_model_summary or get_geometry_bodies, so the agent cannot infer what data will actually be returned.

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

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

No guidance is provided about when to use this tool versus the many get_* siblings. The 'READ ONLY' label adds safety context but gives no selection criteria or exclusions.

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

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

No annotations are provided, so the description carries the behavioral burden. It does explicitly disclose '[READ ONLY]' and uses the non-mutating verb 'Inspect', which is useful. However, it does not mention prerequisites, limitations, or what happens if no model is active, leaving behavioral context relatively thin.

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

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

The description is a single sentence with 'READ ONLY' front-loaded, making it concise and scannable. Every word earns its place, though the content is slightly generic and under-specified for a tool in a large sibling family.

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 tool has no parameters and an output schema exists, so return-value details are covered and do not need to be explained. However, the description does not say that this returns mesh-specific statistics or when to choose it over get_model_summary or get_geometry_bodies, which is a noticeable gap given the many sibling tools.

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

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

The tool takes zero parameters and the schema is empty with 100% coverage, so the baseline for a no-parameter tool is 4. The description adds no parameter detail, but none is needed because there is nothing to document.

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 clear verb and resource ('Inspect Mechanical model data') and explicitly labels the operation READ ONLY, but it does not mention 'mesh statistics' or differentiate itself from similar inspection siblings like get_model_summary and get_geometry_bodies. It is not a tautology, but it is too generic to be a precise purpose statement.

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

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

There is no guidance on when to use this tool versus alternatives. The description does not say that this tool is for mesh-specific statistics, name any sibling for comparison, or mention prerequisites such as an active Mechanical model or connection. An agent must infer usage entirely from the tool name.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The '[READ ONLY]' prefix is a helpful hint, but it does not explain what kind of messages are returned, whether the data is cached or live, or any side effects. This is insufficient for a tool that likely retrieves diagnostic or status messages.

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

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

The description is a single short sentence and is technically concise, but it is under-specified. It is not verbose, but it sacrifices clarity for brevity, making it more of a stub than a well-structured explanation.

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?

Even though an output schema exists, the description does not clarify what 'messages' refers to or how this tool differs from the numerous other inspection tools. With no parameters and a generic purpose, the agent lacks enough context to confidently select and invoke it.

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

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

The tool has zero parameters and the schema is empty, so there is nothing for the description to add about parameters. Per the baseline for 0 parameters, a score of 4 is appropriate because the description cannot compensate for non-existent parameter details.

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 'Inspect Mechanical model data', which is extremely generic. It does not specify what 'messages' are, nor does it distinguish this tool from siblings like get_model_summary, get_geometry_bodies, or get_tree, all of which also inspect mechanical model data. The verb 'inspect' is clear, but the resource is undefined.

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 its many siblings. No alternatives are mentioned, and no conditions or prerequisites are provided. An agent would have to guess whether this tool is the right choice for retrieving messages.

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 behavioral disclosure burden. The explicit '[READ ONLY]' prefix and the word 'Inspect' clearly signal a non-mutating operation. It does not add details about prerequisites or return behavior, but the key safety trait is present for a parameterless read-only tool.

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

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

The description is a single front-loaded sentence with no filler. Every word earns its place, and the read-only signal appears at the start.

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 tool is simple, has no parameters, and an output schema exists, so the description does not need to enumerate return values. However, given the large sibling set of model-inspection tools, the vague phrase 'Mechanical model data' does little to clarify what summary content is returned or when this tool is the right choice.

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

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

The input schema has zero properties, so there are no parameters for the description to clarify. The 0-param baseline of 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?

The description states a specific action and resource ('Inspect Mechanical model data') and marks the tool as read-only. However, it does not differentiate from the many sibling get_* tools such as get_geometry_bodies or get_result_summary, 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?

No guidance is given about when to use this tool versus alternatives like get_tree, get_mesh_statistics, or get_result_summary. The description only restates the tool's purpose and provides no context, prerequisites, or exclusions.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. The description only says '[READ ONLY]' which is a hint of safety, but it does not disclose return format, potential errors, or side effects. Since it is an inspection tool, it likely does not modify data, but that is not explicitly stated beyond the hint.

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 extremely concise, with just one sentence. It is front-loaded with '[READ ONLY]' and clear action. It earns its place, but could benefit from a note on what specific data it inspects.

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

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

Given that there are many sibling tools for inspecting different aspects of the model, this description is incomplete because it does not specify what is returned (a list of named selections? their properties?). The output schema exists but is not provided to the agent, so the description must compensate. The description is adequate for a trivial no-parameter tool, but lacks specifics.

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

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

The tool has zero parameters, so the description's job for parameters is trivial. The schema coverage is 100% (vacuously), and the description does not need to explain parameters. It correctly provides a high-level function, which is sufficient.

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 the tool inspects Mechanical model data, which is a clear purpose. However, it is generic compared to siblings that are more specific (e.g., get_geometry_bodies, get_material_assignments). The name 'get_named_selections' suggests it retrieves named selections, but the description does not specify this, so the tool could be confused with other inspection tools.

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

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

No guidance on when to use this tool versus the many sibling inspection tools. For example, it does not distinguish from get_model_summary or get_geometry_bodies. The description does not mention prerequisites, such as needing a connected Mechanical session or an open project, which would help the agent decide.

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 for behavioral disclosure. It does include a useful '[READ ONLY]' flag, signaling that this operation has no side effects. However, it does not mention prerequisites like a connected Mechanical application, nor what happens if no project is open, leaving some behavior implicit.

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

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

The description is a single sentence with the read-only indicator front-loaded. It wastes no words and is appropriately sized for a zero-parameter tool, earning high marks for structure.

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?

Despite having no parameters and an output schema, the description is too generic to disambiguate this tool among 24 siblings. It does not explain what 'project info' encompasses or why an agent would pick this over get_model_summary or get_tree, creating a real tool-selection 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 input schema has zero parameters, so there is nothing for the description to document. Per the baseline for zero-parameter tools, a 4 is appropriate; the description adds no parameter meaning because none is needed.

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

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

The description states a verb ('Inspect') and a resource ('Mechanical model data'), but the resource is broad and could describe many sibling tools such as get_model_summary or get_geometry_bodies. It does not specify what 'project info' actually includes, so it fails to distinguish this tool from its inspection 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 guidance on when to use this tool versus alternatives. No scenarios, prerequisites, or exclusion criteria are mentioned, leaving the agent to guess whether this or another inspection tool is appropriate.

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

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

With no annotations provided, the description carries the behavioral burden. It does disclose read-only intent via '[READ ONLY]' and 'Inspect', which signals a non-mutating operation. However, it does not mention any other behavioral details that could matter, such as whether a solved model must exist or whether results are always available.

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 very short and front-loads the read-only safety signal. Every phrase earns its place without padding material, though the brevity contributes to the under-specification of the tool's actual purpose.

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?

Despite having no parameters and an output schema, the description is not complete enough for reliable tool selection. It does not clarify what a 'result summary' is, when it should be used, or how it differs from nearby sibling tools, so an agent would struggle to choose 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?

The tool has zero parameters, so there is no parameter semantics to clarify. The input schema already fully defines an empty property set, and the description does not need to compensate for any missing parameter coverage.

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

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

The description states a clear action ('Inspect') and a broad resource ('Mechanical model data'), but it never mentions results or summaries, which are central to the tool's name. This makes the purpose vague and fails to distinguish it from siblings like get_model_summary or get_mesh_statistics.

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 get_model_summary or evaluate_results. The read-only tag implies a safe inspection use, but no explicit context, prerequisites, or exclusions are provided.

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

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

There are no annotations, so the description carries the full burden. The leading '[READ ONLY]' text clearly discloses the non-mutating nature of the tool, which is valuable. However, it stops there: it does not state whether the returned status may be stale, require a solve to have been started, or reflect any other behavior such as a server round-trip.

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 one short sentence, with '[READ ONLY]' front-loaded and no filler. It wastes no words and immediately communicates the most important behavioral constraint.

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?

Although the tool has no parameters and an output schema, the description does not help an agent understand what 'solution status' returns or how it fits with siblings such as mechanical_status, get_result_summary, or evaluate_results. The vague 'Inspect Mechanical model data' is too incomplete for an agent to use in a coordinated workflow.

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

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

The tool takes zero parameters, and the schema has 100% coverage of that (an empty object). The description does not need to explain any parameters, so the baseline of 4 applies; there is no missing parameter-level meaning to compensate for.

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

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

The description says 'Inspect Mechanical model data,' which is broad and vague. It never mentions 'solution status' or 'status', so an agent cannot tell this apart from siblings like get_model_summary, get_result_summary, or get_mesh_statistics. The verb–resource pair is present but the actual purpose is not pinned down.

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

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

No guidance is given for when to call this tool versus any alternative. It does not name sibling tools, exclude cases, or indicate that it should be used after solve_analysis or solve_analysis. The only signal is the read-only tag, which speaks to safety, not selection timing.

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

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

The description includes '[READ ONLY]' which discloses the read-only nature of the tool, a useful behavioral trait. However, no annotations are provided, so the description carries the burden; it does not mention what 'bounded' means (e.g., depth limit, size limit) or any other behavioral details like performance or error conditions. The read-only hint adds value but is minimal.

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

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

The description is a single, concise sentence that front-loads the read-only hint and states the core function. Every word earns its place, and there is no redundant 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?

The tool has one optional parameter and an output schema, so the description need not explain return values. However, the description does not clarify what 'bounded' means in practice (e.g., max_depth semantics, default behavior, or how the hierarchy is structured). Given the simplicity of the tool, the description is adequate but leaves the parameter's effect implicit.

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 undocumented 'max_depth' parameter. The description's word 'bounded' hints that max_depth controls the hierarchy depth, but it does not explicitly explain the parameter's meaning, default behavior, or valid range. This is a partial compensation, but not enough to fully clarify the parameter semantics.

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

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

The description states a specific verb ('Return') and resource ('bounded model-tree hierarchy'), which clearly identifies what the tool does. It does not explicitly distinguish it from sibling tools like get_model_summary or get_project_info, but the 'model-tree hierarchy' phrasing is specific enough to convey its 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?

The description implies usage by indicating it returns a bounded model-tree hierarchy, but it does not explicitly state when to use this tool versus alternatives like get_model_summary or get_project_info. There is no exclusion or alternative guidance, so the agent must infer context from the tool name and sibling list.

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

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

The description explicitly marks the tool as READ ONLY, which is a useful behavioral disclosure given no annotations exist. It also clarifies it operates on a saved project, implying it does not require an open session. However, it does not disclose any failure modes, prerequisites, or side effects beyond the read-only nature, which is minimal but adequate for a simple inspection 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?

One concise sentence with the read-only flag front-loaded. No filler or redundancy. The information density is high for its length.

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 tool is simple with one parameter and an output schema, so the description covers the core action. However, it lacks context on when to use it relative to sibling inspection tools and does not clarify whether the project must be opened first or if it reads directly from disk. This leaves some operational ambiguity for an agent.

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 mentions 'saved Workbench project', giving context that project_path should point to a saved project, but does not specify expected format, file type, or path structure. For a single parameter, this is insufficient semantic addition beyond the parameter name itself.

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 (enumerate) and resource (systems and cells in a saved Workbench project). The purpose is clear, though it does not explicitly differentiate from sibling tools like get_tree or get_project_info, leaving some scope ambiguity.

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 siblings. It does not mention alternatives or conditions that would select this tool over others like get_project_info or get_tree. The description only implies use for inspecting project structure without explicit context.

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

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

No annotations are provided, so the description carries the behavioral burden. The leading '[READ ONLY]' explicitly signals a non-mutating operation, which is valuable context. It does not describe further traits, but for a simple status tool this is adequate.

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 extremely concise: a bracketed read-only flag and a single informative sentence. Every word adds value, and the key behavioral note is front-loaded.

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

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

For a zero-parameter, read-only status tool with an output schema available, the description is complete. It states the operation, the resource being inspected, and the non-mutating nature. No critical information 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?

The tool has zero parameters, so there is no parameter semantic burden on the description. The baseline of 4 applies, and no additional parameter explanation is needed.

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

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

The description uses a specific verb ('Report') and a clear resource ('MCP and Mechanical connection state'). It is easily distinguished from siblings like 'connect_mechanical' (an action) and 'workbench_status' (a different status scope), so an agent can tell what this tool does without opening schemas.

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

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

The phrase 'Report connection state' gives clear context: use this when you need to inspect whether MCP and Mechanical are connected. It does not explicitly name alternatives or exclusions, but for a zero-parameter status check the intended usage is straightforward.

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?

Despite having no annotations, the description proactively discloses that the tool '[MODIFIES MODEL]', a non-obvious behavioral trait that could affect the model state. This goes beyond a plain 'open' action and helps the agent understand side effects. However, it does not elaborate on the nature or extent of the modification.

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

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

The description is a single, front-loaded sentence with no waste. It places the critical modification note at the start, immediately conveying an important side effect. Perfectly concise.

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 one-parameter tool with an output schema, the description might be expected to cover the essential usage context. However, the complete lack of parameter details and usage guidance means the agent cannot reliably call this tool. The modification warning adds value, but the description is insufficient for correct 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?

The input schema has a single 'path' parameter with zero description coverage, and the tool description adds no explanation of what format, type, or location the path should be (e.g., absolute/relative, file extension). The agent receives no additional meaning beyond the parameter name, leaving the parameter's semantics completely undefined.

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 clearly states the tool's action ('Open') and the resource ('Mechanical project/database file'), which differentiates it from siblings like 'connect_mechanical' (connecting to an existing session) or 'get_project_info' (retrieving info). The meaning is unambiguous and specific.

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

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

No guidance is provided on when to use this tool versus alternatives. It does not mention that this tool should be used before accessing project data, nor does it indicate when the user might prefer 'connect_mechanical' or 'get_project_info'. The description gives no situational context.

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

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

Without annotations, the description must carry side-effect disclosure; [WRITES FILE] usefully flags that a file is created/modified and 'beneath configured output directory' hints at path scope. But it doesn't state whether existing files are overwritten, whether directories are created, or how path is resolved relative to the configured directory.

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

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

A single sentence with a clear prefix; no filler. It is compact and front-loaded, but the brevity comes at the cost of missing behavior and parameter detail.

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 tool is simple with one parameter and has an output schema, so the return value need not be described. Still, the behavior around existing files and path resolution is undocumented, so an agent cannot predict side effects precisely.

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 description adds only the location constraint ('beneath configured output directory') for the path parameter. It does not specify whether path is a full file name, relative subpath, extension handling, or what happens when it points outside the output directory.

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 concrete action ('Save a copy') and a destination ('configured output directory'), and the [WRITES FILE] prefix signals persistence. However, it doesn't explicitly say it is saving the current project/session, so an agent has to infer the object from the tool name and sibling 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?

No guidance on when to use this tool over alternatives like open_project or other saving/workflow steps; no exclusions or prerequisites are given. The description only names the operation, so an agent gets no decision support.

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

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

The '[MODIFIES MODEL]' tag is a weak behavioral indicator, but the description doesn't state whether this overwrites existing components, merges them, or only accepts specific values. It doesn't describe side effects like validation failures or partial modifications. With no annotations provided, the description carries the full burden but fails to explain the behavior beyond 'set components.' This is a significant gap.

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

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

The description is extremely short, but this is under-specification rather than conciseness. It front-loads the '[MODIFIES MODEL]' modifier, which is useful, but the rest is a single sentence that omits essential information. A well-structured description should provide enough detail without being verbose, and this falls below that threshold.

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 tool that modifies model state, with two parameters including a nested object, and no annotations or output schema explaining return values, the description is woefully incomplete. It doesn't mention what the tool returns (though there is an output schema, the description doesn't add context), nor does it explain how components interact with existing model data. Given the complexity of the action, this is completely inadequate.

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

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

Schema description coverage is 0%, so the description must compensate for missing parameter explanations. It doesn't define what 'components' means: what are the keys and values? Are they material names, load magnitudes, or something else? 'load_name' is fairly self-explanatory, but 'components' is an open-ended object that the description completely fails to clarify. This is a critical deficiency.

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 starts with '[MODIFIES MODEL]' and says 'Set components on one existing named load.' It clearly indicates the action is to modify a load by setting components, and it specifies that the load must already exist. This distinguishes it from other sibling tools like set_material_assignment or create_named_selection. However, 'components' is vague and the description doesn't elaborate on what kinds of components beyond the schema.

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

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

There is virtually no guidance on when to use this tool versus others. It doesn't mention prerequisites (e.g., the load must exist, should be created first), nor does it contrast with create/delete load tools. No statement on typical usage scenarios or limitations. The only hint is that it modifies an existing load, but it doesn't explain why an agent would need this versus other actions.

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

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

The [MODIFIES MODEL] prefix explicitly warns that this is a mutating operation, which is important given there are no annotations. Still, the description does not disclose whether an existing material assignment is overwritten, whether the body must already exist, or any side effects beyond the modification.

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

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

The description is a single, efficient sentence with the important mutation warning front-loaded. Every word earns its place and there is no redundant or vague 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?

For a two-parameter setter, the description is mostly usable but leaves key invocation details unstated, such as valid material formats, overwrite behavior, and preconditions. The presence of an output schema reduces the need to document return values, so the overall context is adequate but not complete.

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

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

Schema description coverage is 0%, so the description must compensate. It clarifies that body_name refers to a uniquely named body, but it adds no detail about material values, valid naming conventions, or how to obtain an appropriate material string. This is only minimal compensation for the missing parameter descriptions.

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 uses a specific verb ('Assign') and clear resource ('material') with a precise target ('one uniquely named body'). It communicates the core action effectively and distinguishes itself from read-oriented siblings like get_material_assignments, though it does not explicitly name an alternative.

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 when to use the tool: when you want to set a material on a single named body. However, it provides no explicit guidance about alternatives, prerequisites, or situations where a different tool (e.g., get_material_assignments) would be more appropriate.

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

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

The description starts with '[MODIFIES MODEL]', which explicitly signals a side-effectful operation—an important behavioral disclosure since no annotations are provided. It also clarifies the scope ('global'). However, it does not disclose consequences such as invalidating an existing mesh, requiring regeneration, or whether the setting is persistent.

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

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

The description is a single, front-loaded sentence with a useful side-effect indicator. Every word contributes: the mutation warning, the action, the scope, the target, and the unit constraint. There is no fluff or repetition of the tool 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?

The tool is simple with one parameter and an output schema, so the description does not need to explain return values. Still, it omits practical context such as when to call this relative to generate_mesh or how the chosen size affects subsequent operations. It is adequate for a basic setter but not fully complete.

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

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

The schema provides no description for element_sizetonight, and schema coverage is 0%. The phrase 'with units' adds meaning by indicating that the required string should include a unit, but it does not explain supported unit formats or whether unitless values are allowed. It partially compensates for the schema gap but leaves ambiguity.

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 clearly states a specific action ('Set') on a specific resource ('global mesh element size') and adds a formatting constraint ('with units'). It is not a tautology, and an agent can tell it apart from generate_mesh and get_mesh_statistics, though it does not explicitly distinguish itself from 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?

No guidance is given about when to call this tool versus alternatives. There is no mention that mesh size should be set before generate_mesh, or that generate_mesh is the follow-up action needed to apply the size. The intended usage is only implied by the verb 'set' and the sibling tool list.

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

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

No annotations are provided, so the description must fully disclose behavior. It fails to mention that solving is a potentially long-running operation, whether it modifies the project state, or what side effects occur. It only states a generic action without any transparency.

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 extremely short, but that brevity is under-specification rather than conciseness. It front-loads the purpose but lacks any structuring or additional context. A single sentence that says almost nothing is not efficient because it fails to convey necessary 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?

Despite having an output schema empties and no annotations, the description is massively incomplete. For a tool that triggers a solve operation in a simulation context, an agent needs to know expected inputs, side effects, prerequisites, and what the output will contain. None of this is provided.

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

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

Schema description coverage is 0% and the description adds no meaning for the single parameter 'analysis_name'. It doesn't explain what an analysis name is, where to find it, or any constraints. The schema only says it's a string; the tool description adds nothing.

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 is vague: 'Solve one uniquely named analysis' names the action and object but doesn't specify what 'solving' means, what the analysis is, or how it differs from sibling tools like 'evaluate_results' or 'get_solution_status'. It does not distinguish itself from these related tools.

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

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

No guidance on when to use this tool versus alternatives. There is no mention of prerequisites (e.g., mesh must be generated), no context about what solving entails, and no reference to sibling tools that might be more appropriate for checking status or evaluating results.

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

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

The description includes '[READ ONLY]' which discloses the non-mutating behavior, and 'batch-runner configuration' clarifies the scope. However, annotations are absent, so the description carries the burden; it doesn't disclose what the report contains, whether it reflects live state, or any side effects. The '[READ ONLY]' tag adds some transparency but not deep behavioral context.

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

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

The description is a single, front-loaded sentence with no wasted words. '[READ ONLY]' is placed at the start, immediately signaling safety, and the rest states the exact resource being reported. Every word earns its place.

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

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

For a zero-parameter, read-only status tool with an output schema present, the description is nearly complete. It could benefit from a hint about what 'batch-runner configuration' includes (e.g., paths, versions, settings), but the output schema likely covers return values, and the tool's simplicity lowers the bar.

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 is no parameter semantics burden on the description. The schema is trivially complete (100% coverage with an empty properties object), and the description correctly implies no inputs are needed. Baseline 4 for zero-parameter tools 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 states a specific verb ('Report') and resource ('Workbench batch-runner configuration'), which clearly identifies what the tool does. It doesn't explicitly distinguish from siblings, but the '[READ ONLY]' prefix and the specific 'batch-runner configuration' scope help differentiate it from other status tools like mechanical_status.

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 this is a read-only status check, and the '[READ ONLY]' prefix signals safe usage. However, it doesn't explicitly state when to use this tool versus alternatives like mechanical_status or get_solution_status, nor does it mention any exclusions or prerequisites.

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