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 disclosure and does not meet it. It never states whether unsaved changes are discarded, whether closing releases a simulation license, or whether the call errors when nothing is open — all critical for an irreversible close operation.

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

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

A single front-loaded sentence with no filler. It is efficient, though the terse phrasing leaves no room for a side-effect warning that would genuinely earn 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?

The output schema covers return values, and the tool is simple with no parameters. However, for a state-changing close operation with zero annotation coverage, the description omits the one thing an agent most needs to know: whether calling it risks losing unsaved work.

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

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

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

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

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

States a specific verb+resource (close the open Rocky project), which is distinguishable from siblings like rocky_open_project, rocky_create_project, and rocky_save_project. It does not clarify what happens to unsaved state, but the operation itself 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 guidance on when to call it, no mention of whether the project should be saved first, and no statement about what happens if no project is open. The agent must infer the workflow from sibling names.

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 delivers none of it: it does not say the tool may launch a fresh Rocky process versus attach to an existing one, whether the call blocks, what permissions or license it needs, or what happens on failure. The one thing disclosed — that it connects — is already in the 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?

A five-word sentence has zero waste and is front-loaded, but it is under-specified rather than concise — there is no second sentence to earn a place. Shortness here reflects missing content, not efficient editing.

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, but for a session-establishing tool with process-launching side effects and zero annotations, the description should at minimum state that other rocky_* calls depend on it and that mode controls launch-vs-attach. It omits both.

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 100%, with exe, mode, port, and version each fully documented in the schema, so the baseline of 3 applies. The description adds no parameter meaning of its own, but it does not need to given the schema quality.

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 and a resource ("Connect to Ansys Rocky"), so an agent knows it establishes a session with Rocky. But it adds nothing beyond the name/title pairing and does not distinguish it from siblings like rocky_disconnect or rocky_status, which bookend the same lifecycle. Purpose is recognizable but vague.

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: nothing says this must be called before other rocky_* tools, nor how it relates to rocky_disconnect or to project tools. The launch/attach choice is documented only in the schema's mode parameter, not in the description. Usage is at best implied.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it says nothing about persistence, side effects on the referenced surface, duplicate-inlet behavior, or required project state. It does at least make clear that this is a mutating creation operation, but that is the bare minimum.

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 action and the key setting appear immediately. Nothing in the sentence 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?

The output schema covers return values and the schema covers all parameters, so the remaining gap is behavioral: prerequisites (open project, existing surface and particle) and side effects are unstated. For a creation tool with zero annotations, that leaves a meaningful hole an agent could trip over.

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 100%, so all four parameters (surface_id, particle_id, mass_flow_rate, unit) are already documented in the schema. The description adds no format, unit-range, or default information beyond the schema, so the baseline 3 applies.

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

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

States a specific verb and resource ('Create a particle inlet on a surface') plus the key configuration it performs ('set its mass flow rate'). It does not explicitly distinguish itself from the closely named sibling rocky_create_outlet, so the agent must infer the inlet/outlet distinction from the names alone.

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 rocky_create_outlet or other setup tools, and no mention of prerequisites such as an open project or pre-existing surface/particle definitions, even though surface_id and particle_id are required. Usage must be inferred 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 behavioral burden. For a creation/mutation tool, it does not disclose side effects, whether the outlet is auto-connected, required surface state, or failure conditions; the output schema only covers return values, not this 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 single sentence is front-loaded and wastes no words. However, it is terse enough that it leaves important usage and behavioral context unstated.

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

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

Given this is a mutation tool with no annotations and several related sibling tools, the description is incomplete: it omits prerequisites, relationship to inlet/connect tools, and side effects. Output schema existence reduces the need to explain return values, but not behavior.

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 100%, so surface_id is already well documented as the exit-point surface identifier. The description's phrase "on a surface" reinforces that but adds no syntax or formatting detail beyond the 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 states a specific verb and resource: create a Rocky outlet on a surface. It is clear enough to distinguish this from most sibling tools, but it does not explicitly contrast with rocky_create_inlet or rocky_connect.

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 does not say when to use an outlet versus an inlet, when connection is needed, or what prerequisites must exist. The agent is left to infer usage 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?

With no annotations provided, the description carries the full burden but discloses almost nothing. It implies a mutation (create) yet says nothing about required project state, permissions, persistence, reversibility, or whether defaults are applied to unspecified fields.

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 a single efficient sentence with no filler. However, that brevity is closer to under-specification than to disciplined conciseness, so it doesn't merit 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?

For a creation/mutation tool with four parameters, no annotations, and no output schema explanation, the description is too thin. An output schema exists so return values needn't be described, but the absence of behavioral or usage context leaves an agent insufficiently equipped to call it correctly in a configured study.

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 100%, so the schema already documents name, unit, shape, and sieve_size, including that sieve_size drives mass and throughput. The description adds no semantics beyond the schema, making the baseline 3 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?

States a clear verb ("Create") and resource ("Rocky particle definition"), so an agent knows it produces a particle entity. It doesn't differentiate it from other creation siblings or explain what a particle definition is, but the core action is unambiguous.

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

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

The description offers no when-to-use guidance, no prerequisites, and no alternatives. It never says whether a particle must be attached to an inlet or configured within a project, leaving usage 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 and does disclose the key destructive side effect: any previously open project is replaced and the object registry is reset. It stops short of stating whether unsaved work is lost or prompts appear, but the critical consequence is surfaced.

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 and immediately followed by the side effect. Every sentence earns its place.

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

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

An output schema exists and there are no parameters, so return values and inputs need no explanation. The one thing an agent must know before calling — that it replaces the open project — is stated.

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?

Zero parameters, so the baseline is 4; there is nothing for the description to disambiguate and it correctly does not invent parameter detail.

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

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

Specific verb plus resource ('Create a new, empty Rocky project'), with 'new, empty' implicitly distinguishing it from rocky_open_project. It does not name that sibling explicitly, so the differentiation is inferable rather than stated.

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

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

Usage is implied by the 'new, empty' framing against rocky_open_project, but there is no explicit when-to-use / when-not, and no mention of prerequisites such as whether an existing project must be saved first.

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

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

No annotations are provided, so the description carries the full behavioral burden. It only says 'Create' — it does not state whether the selection is added to the current project, whether existing selections are affected, what permissions or project state are required, or that this is 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?

It is a single, front-loaded sentence with no wasted words, but it is under-specified rather than genuinely concise — brevity here comes at the cost of needed context.

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

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

Although an output schema exists (so return values needn't be described), a creation tool with six optional parameters and no annotations needs more: preconditions, what the selection is used for in post-processing, and any effects on project state are all 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 100%, so parameters like kind, size, center, and final_angle are already well documented in the schema. The description adds no semantic detail beyond what the schema provides, making the baseline 3 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 verb 'Create' and resource 'selection' are named, but 'selection process for post-processing' is vague about what a selection actually is in Rocky (a geometry region such as a cylinder or cube) and how it differs from siblings like rocky_create_surface. An agent gets the general idea but not a crisp, sibling-distinguishing definition.

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 rocky_create_surface or other geometry-creation siblings, and no prerequisites stated (e.g., whether a project must be open first). The post-processing mention is the only contextual hint.

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, yet it says nothing about state mutation, persistence, required preconditions, error behavior, or what happens if radius/width/length are omitted. Only the bare mutation ('create') is 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?

A single front-loaded sentence with no filler or redundancy. It is appropriately sized, though it is arguably over-compressed given the tool's conditional parameters.

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

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

Return values need not be explained since an output schema exists, and the schema fully documents the seven parameters including shape-conditional requirements. However, for a mutation tool with zero annotations, the description should still state preconditions and side effects, which it omits.

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

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

Schema description coverage is 100%, including the shape-conditional requirements for radius vs. width/length, so the baseline is 3. The description adds no parameter meaning beyond the schema (no units interaction, no defaults discussion, no center semantics).

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

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

States a specific verb+resource ('Create a ... Rocky surface') and names the two supported shapes, which lets an agent distinguish it from siblings like rocky_create_inlet or rocky_create_particle by the object being created. It does not explicitly contrast with those siblings, keeping it 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 prerequisites (e.g., whether a project/study must already be open), and no exclusions or alternatives mentioned. The agent must infer context entirely from the 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?

With no annotations, the description carries the full burden and does well: 'Describe' plus 'Returns...' makes clear this is a non-mutating inspection, and 'the open project' signals the precondition that a project must be open. It does not explicitly state that nothing is modified or what happens when no project is open, which is the remaining 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?

Front-loaded with the purpose, followed by the returned content and then the usage cue — well ordered and free of filler. The long enumeration of return fields partially duplicates the output schema, which is the only redundancy.

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

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

For a zero-parameter read tool with an output schema, the definition covers purpose, scope, precondition, and invocation timing. Missing only explicit assurance of read-only behavior and the failure mode when no project is open.

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

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

The tool takes zero parameters, so there is no parameter semantics to explain; the baseline for a parameterless schema applies. Nothing in the description contradicts or muddies the empty schema.

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

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

States a specific verb and resource ('Describe the open project and study') and enumerates exactly what is reported, which lets an agent distinguish a full study dump from the lighter-looking siblings rocky_status and rocky_simulation_status. It never names those siblings explicitly, so differentiation is implicit rather than stated.

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

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

'Call this after any setup step to confirm what the study actually contains' gives a concrete trigger for invocation. It stops short of naming alternatives or exclusions (e.g., when to prefer rocky_status for a quick check), so the agent must infer the boundary.

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 disclose the effect (session released/terminated), but says nothing about whether the call is idempotent, what happens if no session is active, or whether unsaved state or a still-open project is affected.

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

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

A single short sentence with the action front-loaded and no filler. Nothing is wasted, and the meaning lands 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?

An output schema exists, so return values need no explanation, and with zero parameters the surface area is tiny. Still, for a session-terminating operation with no annotations, the description should say whether open projects or unsaved work are affected and whether requiring an active connection can cause an 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 tool takes zero parameters, so there is nothing for the description to disambiguate; the empty schema is fully self-explanatory. 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?

The description names a specific verb ('Disconnect') and resource ('Ansys Rocky'), and 'release the session' clarifies the scope. Its counterpart rocky_connect makes the intent unambiguous, though the description doesn't explicitly contrast itself with rocky_close_project, which is the nearest ambiguous sibling.

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?

'release the session' implies this is a teardown/end-of-work call, so usage is inferable. However, it gives no explicit when-to-use guidance, no statement about whether rocky_close_project or a save must happen first, and no note on how this differs from simply closing the project.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Read' implies non-destructive access, but it does not state permissions, side effects, error behavior, or required simulation state. The output schema reduces return-value concerns, but significant behavioral gaps remain.

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 zero waste, front-loading the verb and resource. It is appropriately concise, though it borders on being too terse for a tool with selection and unit options.

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 low complexity, full schema coverage, and an output schema, the description is minimally adequate. It still lacks prerequisite and selection-context guidance, which an agent would need 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 100%, so the schema already documents all three parameters thoroughly. The description adds no additional meaning beyond the schema, so the baseline score of 3 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?

States a specific verb ('Read') and resource ('a time series produced by the simulation'). The intent is clear, though it does not explicitly differentiate from siblings; however, there are no other curve-reading siblings, so this is acceptable.

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 no indication of when to use this tool versus alternatives such as rocky_list_processes or rocky_get_grid_function_stats. It also omits prerequisites like needing an open project or a completed simulation, leaving usage entirely implied.

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 burden. 'Read' makes the non-mutating nature clear and 'over the time set' usefully scopes the statistic to the temporal domain rather than space. However, it discloses nothing about required session/project state or failure behavior when the name is invalid.

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 that leads with the verb and resource and contains no filler. Nothing to trim.

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

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

An output schema exists, so return values need not be described. Combined with a fully documented schema, the description supplies everything essential for a simple two-parameter read, though prerequisite state (open project) is left 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 100%: both the name parameter (with a concrete example) and the unit parameter are documented in the schema. The description adds no additional parameter meaning, such as whether unit converts values or filters them, so the baseline 3 applies.

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

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

States a specific verb and resource: reads the min/max of a named grid function over the time set. That is clearly distinct from rocky_get_curve (curve data) and rocky_list_grid_functions (enumeration). It does not explicitly name those siblings, but the operation 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 guidance on when to prefer this over rocky_get_curve or rocky_list_grid_functions, and no stated prerequisites (e.g., an open project, or that the grid function name must come from rocky_list_grid_functions). The agent must infer usage entirely from the one-line 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?

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing about side effects, whether import creates one wall per body, whether existing walls are preserved, or what happens with unsupported formats. An output schema exists, so return values need not be explained, but the mutation semantics remain opaque.

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

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

A single front-loaded sentence with no filler or redundancy. However, its brevity is closer to under-specification than to disciplined compression.

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

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

For a mutation tool with zero annotations, the description leaves out prerequisite state (project open?), the implied multi-wall behavior suggested by name_prefix, and any failure handling for unsupported geometry formats. Rich schema and output schema cover much of the surface, but the behavioral gap is still 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 100%, so path, scale, and name_prefix are already fully documented in the schema. The description adds no meaning beyond that baseline, which is acceptable but not additive.

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 ("Import") with a concrete resource ("a geometry file as a Rocky wall"), which lets an agent tell it apart from construction siblings like rocky_create_surface. It stops short of explicitly differentiating itself from those siblings, so it is clear but not maximally distinctive.

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

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

The description offers no when-to-use guidance, no prerequisites (e.g., whether a project must be open first), and no alternatives such as rocky_create_surface for other wall-building paths. The agent must infer all routing decisions from sibling names 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 disclosure burden, yet it says nothing about whether an open project/study is required, what happens if none exists, or whether the call is read-only. The presence of an output schema covers return values, but the operational preconditions are undisclosed.

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

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

A single front-loaded sentence with no filler. It is efficient, though so terse that it borders on under-specification rather than optimal density.

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 list tool with an output schema, the description is minimally sufficient to call it correctly. However, it omits the precondition (an open study/project) and any hint about result shape or scale, which matters in a large sibling set with project-lifecycle tools.

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

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

The tool takes zero parameters, so there is nothing for the description to document. Baseline 4 applies; the phrase 'for the current study' usefully clarifies that the scope is implicit rather than parameterized.

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 ('List') and resource ('grid functions'), scoped to 'the current study'. The purpose is unambiguous, but it gives no cue as to how it differs from near siblings like rocky_list_processes or rocky_get_grid_function_stats.

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

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

There is no statement of when to call this versus alternatives, no prerequisite conditions (e.g., a project must be open), and no exclusions. The agent must infer usage entirely from the name.

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

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

With no annotations, the description carries the burden; 'List' at least implies a read-only, non-destructive operation and scopes it to 'the study'. However, it says nothing about permissions, whether 'the study' means the currently open project, or whether results are paginated/filterable.

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

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

A single, front-loaded sentence with no filler. It is efficient, though its brevity leaves the two listed nouns unexplained.

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 zero-parameter schema keeps invocation simple. Still, the description could clarify what a 'user process' is and whether listing is project-scoped, which matters for a discovery tool in a large sibling set.

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 disambiguate; baseline 4 applies and the description has no parameter burden 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?

States a specific verb, 'List', plus two resources: user processes and registered objects of the study. This clearly differentiates it from siblings like rocky_list_grid_functions or rocky_describe_study, though 'user processes' and 'registered objects' are Rocky-specific terms an outsider can't fully resolve.

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

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

There is no indication of when to call this versus rocky_describe_study or rocky_status, nor any prerequisites or exclusions. The agent must infer usage purely 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?

With no annotations, the description carries the full burden of behavioral disclosure. Opening a project is a state-mutating operation, yet the description says nothing about whether it replaces the current project, what happens if the path is invalid or missing, or what permissions are needed. The only signal is the output schema, which the agent would have to inspect.

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

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

One short sentence with the verb and resource front-loaded and no filler. It is efficient, though efficiency here shades into under-specification rather than disciplined brevity.

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 state-changing tool with zero annotation coverage, the description omits prerequisites, side effects on the current session, and error conditions. The presence of an output schema removes only the need to explain return values; everything else an agent needs to invoke this safely 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 100%: the single 'path' parameter is already documented as pointing to a '.rocky' project file. The description adds nothing beyond that, so the baseline of 3 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?

A specific verb ('Open') plus a specific resource ('existing Rocky project file') makes the action unmistakable, and 'existing' distinguishes it from the sibling rocky_create_project. It does not, however, differentiate itself from rocky_save_project or rocky_close_project, which share the same project-file domain.

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 statement of when to use this versus rocky_create_project, nor any guidance on prerequisites (e.g., whether a project must be closed first, whether state is replaced). 'Existing' hints at the condition, but the agent is left to infer everything else.

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 does disclose the most important trait — session state persists across calls, so variables survive — which an agent must know. It says nothing about execution privileges, side effects on the Rocky project/session (e.g., does it mutate the model?), error semantics when code raises, or whether the session can be reset, all material for arbitrary code execution.

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, front-loaded with the action, with no wasted preamble. Slight redundancy: sentence one already says "persistent Python session" and sentence three restates persistence, so the statefulness could have been stated once and expanded once.

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?

Output schema exists and parameters are fully documented, so return values need not be explained. However, for an arbitrary-code-execution tool with no annotations, the description omits what an agent most needs before invoking: available modules/API surface inside the session, effect on persistent state of failures, and whether execution is sandboxed.

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 100%, with both `code` and `timeout` documented including a default, so the baseline of 3 applies. The description adds no extra semantics such as whether the timeout kills the session or how to access the Rocky API from inside `code`.

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 ("Run arbitrary Python code") and names the execution environment ("persistent Python session"), which no sibling tool occupies. The second sentence explicitly positions it against the domain-specific siblings, so an agent can distinguish it without opening the schema.

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

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

The phrase "escape hatch for anything the dedicated tools do not cover" gives a clear selection rule favoring the named-style siblings, which is unusually good routing context. It stops short of explicit exclusions (e.g., "prefer rocky_run_simulation for simulations") or guidance on what to do when the code fails.

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, and it says nothing. The blocking vs non-blocking behavior, the destructive effect of delete_results, and any state prerequisites appear only in the schema, not the description.

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 with no padding, but it is under-specified rather than efficient — the brevity comes at the cost of every useful 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?

An output schema exists so return values need not be explained, but for a stateful mutation tool with zero annotation coverage the description is far too thin. It omits the fact that this starts a long-running job that must then be polled, which is the key operational fact 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 100%, so both parameters (non_blocking, delete_results) are already fully documented in the schema. The description adds no meaning beyond that, so the baseline of 3 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?

"Start the Rocky simulation" names a specific verb and resource, so the basic action is inferable. However, it never distinguishes itself from siblings like rocky_wait_for_completion or rocky_simulation_status, which an agent could easily confuse with launching a run, and it says nothing about what the simulation operates on.

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 rocky_wait_for_completion or rocky_simulation_status, and no stated prerequisites (project open, study described, simulation settings configured). The agent must infer the whole workflow from sibling names.

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 saving overwrites an existing file, what happens if no project is open, or any permission or side-effect details beyond the basic save action.

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

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

The description is a single front-loaded sentence with no wasted words. It is appropriately sized for a simple save operation.

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

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

The tool is simple, the only parameter is fully documented in the schema, and an output schema exists. However, without annotations, the description should say more about save behavior, error conditions, and whether the operation is destructive or overwrite-prone.

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 100%, and the path parameter is fully documented in the schema itself. The description adds no additional meaning beyond what the schema already provides.

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: 'Save the open Rocky project.' It clearly identifies the operation and its scope, though it does not explicitly differentiate from siblings like rocky_open_project or rocky_close_project.

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 only implied usage condition is that a Rocky project must already be open. There is no guidance on when to use this versus related tools such as rocky_open_project, rocky_close_project, or rocky_create_project.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not explain whether an open project is required, whether omitted/null parameters leave existing limits unchanged or reset them, how use_boundary_limits interacts with min_values/max_values, or what the response contains—significant gaps for a mutation tool.

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

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

The description is a single front-loaded sentence with no wasted words, but it is terse to the point of being under-specified rather than optimally 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?

Although an output schema exists and parameter schemas are fully described, four optional mutation parameters with default null values demand more context about side effects, null handling, and prerequisites than this one-line description provides.

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 100%, so the schema already documents all four parameters, including defaults and coordinate formats. The description adds no parameter-level meaning beyond what is in the schema, which is the baseline expectation when coverage is high.

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

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

The description has a specific verb ('Configure') and resource ('Rocky domain limits'), but 'domain limits' is vague—it doesn't clarify that this sets computational domain extents via min/max coordinates or boundary limits. It does not distinguish the tool from siblings like rocky_set_simulation_settings or rocky_set_motion.

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, what prerequisites exist (e.g., an open project), or how it relates to alternatives such as rocky_import_wall or rocky_create_surface. The single sentence leaves all usage conditions to inference.

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

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

No annotations are provided, so the description must carry the behavioral burden. It implies a mutation (applying motion) but does not disclose side effects, persistence, permission requirements, whether existing motion is replaced, or how the study state is affected.

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

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

The description is a single front-loaded sentence with no wasted wording. It is concise, though its brevity leaves it with little structural support for a complex 7-parameter mutation 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?

This is a complex mutation tool with seven parameters and no annotations. Although the schema and output schema are rich, the description still lacks essential context about usage conditions, behavioral effects, and the rotation/translation setup, making it incomplete for safe 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 100%, so the input schema already explains all seven parameters in detail. The description adds no parameter-specific semantics beyond what the schema provides, making the baseline score of 3 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 clear action and resource: applying a rotation or translation motion to study objects. It is specific enough to distinguish from most siblings, but it does not explicitly differentiate itself from related setup or simulation 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?

The description gives no guidance on when to use this tool versus alternatives, nor does it mention prerequisites or when not to use it. It only communicates the operation itself, leaving usage decisions 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 behavioral burden and discloses almost nothing: not whether omitted optional parameters reset prior values or are left untouched, whether the configuration is persisted to the project, or whether it must be set before the simulation is launched. Only the bare word 'Configure' signals 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?

A single front-loaded sentence with no filler, so nothing is wasted, but it is under-specified rather than efficiently concise. There is room for one more sentence of routing or statefulness context without bloat.

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 zero-annotation mutation tool with five optional parameters and null defaults, the exact case where the description must explain partial-update semantics and prerequisites. An output schema exists so return values need no explanation, but the missing input-side and ordering context leaves 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 100%, so every parameter is already documented in the schema; the description adds no semantics beyond the schema and does not clarify the important null/default behavior. Baseline 3 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 names a verb ('Configure') and a resource ('Rocky solver settings'), which is enough to know it mutates simulation configuration. However, 'solver settings' is vague relative to the actual parameters (duration, time_interval, processors, execution_mode) and nothing distinguishes it from siblings such as rocky_run_simulation or rocky_set_domain.

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 at all on when to call this tool, whether it must precede rocky_run_simulation, or whether it can be re-invoked mid-study. The agent has to infer sequencing from the sibling list 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 helpfully discloses the returned information (running state, progress, computed time, result availability), but it does not explicitly state that the tool is read-only, whether it polls or takes a snapshot, whether it requires an active simulation, or what happens if no simulation is running.

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 short sentences with no wasted text. The core action is front-loaded, and the return fields are listed compactly.

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

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

An output schema exists, so the description does not need to fully specify return values; the brief return summary is sufficient. For a zero-parameter status tool, the main missing piece is explicit differentiation from rocky_status and rocky_wait_for_completion, but otherwise it is complete enough to invoke 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 the baseline is 4. There are no parameter semantics to clarify, and the description appropriately focuses on the report contents instead.

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 and resource: report the state of the running simulation. It is specific about what is being inspected, but it does not distinguish itself from sibling tools such as rocky_status or rocky_wait_for_completion, so an agent cannot tell from the description alone which status tool applies.

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

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

The phrase 'running simulation' implies the usage context, so an agent can infer this is for checking an in-progress simulation. However, there is no explicit guidance on when to use this versus rocky_status or rocky_wait_for_completion, nor any stated exclusions or prerequisites.

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 burden and does well: it explicitly discloses the absence of a side effect (never launches Rocky) and discloses the categories of information returned. It omits whether the call can block/hang while probing the installed application's reachability — a non-trivial behavioral detail 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?

One sentence of purpose, one sentence enumerating the returned facts, one sentence of usage rule — front-loaded and free of filler. The ordering rule is placed last but is short enough to be read in full.

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?

A parameterless read tool with an output schema needs little more than a purpose statement and a safety note, both of which are present. The remaining gap is disambiguation from rocky_simulation_status in a 25-tool family where 'status' appears twice.

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

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

The tool takes zero parameters, so there is no parameter semantics to explain; the baseline for a parameterless tool applies. The description correctly does not waste space re-describing an empty schema.

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

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

States a specific verb and resource ('Report the status of the Rocky MCP session') and enumerates exactly what the report contains: backend, Ansys Rocky installation/reachability, detected versions, open project, simulation state. It is clear about what it does, but it does not differentiate itself from the sibling rocky_simulation_status, which also appears to surface simulation state.

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?

'Use this first' gives an explicit ordering rule, and 'it is the only tool that never launches Rocky' is a concrete, actionable exclusion criterion that makes it safe to call at any time. It stops short of naming when to prefer rocky_simulation_status over this tool for simulation-state checks.

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

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

No annotations are supplied, so the description carries the full burden, yet it doesn't say what happens on timeout (error vs. return), whether it blocks the caller, or what it does when no simulation is running. Only the basic blocking semantics is implied by the word 'wait'.

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

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

A single front-loaded sentence with zero waste and no filler. Its brevity is efficient, though it veers into under-specification rather than tightness.

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 shape needn't be explained, but for a long-running blocking operation with no annotations the description should cover timeout outcome and preconditions. Those gaps leave an agent unable to predict 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?

Schema description coverage is 100%, so both timeout and poll_interval are already fully documented with defaults. The description adds nothing beyond the schema, which is the baseline case.

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 (wait) and target (running simulation finishing), which is more concrete than a bare name restatement. It does not distinguish itself from siblings such as rocky_simulation_status or rocky_run_simulation, which an agent must choose between.

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 block with this tool versus polling rocky_simulation_status, and no preconditions (e.g. a simulation must already be running). The agent is left to infer the whole selection logic.

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