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

With no annotations, the description must carry full behavioral disclosure. It mentions ordered batching and supported operation types, but says nothing about mutation side effects, session requirements, expected_revision concurrency behavior, request_key idempotency, or failure semantics.

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

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

The definition is a single front-loaded sentence with no wasted words. However, its extreme brevity is under-specification rather than effective conciseness for a complex four-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?

Given four required parameters, 0% schema description coverage, no annotations, and a mutation operation, the description is far too sparse. An output schema exists, so return values need not be explained, but essential call-time context about session, revision, and request key is missing.

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

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

Schema description coverage is 0%, so the description must compensate for four required parameters. It adds only a vague notion of 'ordered batch' for operations and does not explain session_id, expected_revision, or request_key at all.

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

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

States a specific verb ('Apply') and resource ('ordered batch of supported OCC primitives, booleans and transforms'). It clearly distinguishes a batch geometry mutation tool from singular geometry or mesh tools, though it does not name sibling alternatives explicitly.

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

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

No guidance on when to use this tool versus alternatives such as geometry_structured_blocks, geometry_pipe_oh, or geometry_inspect. Usage is only implied by the word 'Apply' and the mention of a batch.

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

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

No annotations are provided, so the description carries the full burden. It discloses what is created (16 connected blocks, automatic boundary naming with specific patch types), the irreversibility of the template (mesh_configure cannot override; a new session is required to change geometry), and the quasi-2D one-cell extrusion. It does not discuss revision-conflict behavior (expected_revision), idempotency, or failure modes, which keeps it short of a 5.

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 operation, then geometry, then naming, then workflow and constraints; every sentence carries information. The coordinate-frame sentence is dense but justified for a geometry builder. Slightly long, but no obvious padding.

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

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

An output schema exists, so return values need no explanation, and the description covers geometry, auto-assigned boundary types, and the surrounding workflow. The main remaining gap is that most of the 15 inputs (especially the cell-count parameters and revision/request-key fields) are left to self-descriptive names, which is a minor but real shortfall for a parameter-heavy template builder.

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

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

Schema description coverage is 0% across 15 parameters, so the description must compensate. It adds real meaning for the geometric params (metres for span/width/length/diameter/upstream, the coordinate frame, first_cell_height, and the 'cell counts' role), but says nothing about the six count parameters individually (radial/upstream/downstream/transition/cross_stream/circumferential cells) or about session_id, expected_revision, and request_key. Partial compensation only.

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 (build a conformal external-cylinder O-H template) and pins down the exact geometry: centre (0,0), x from -upstream to length-upstream, y ±width/2, 16 blocks, one cell in z. It also explicitly distinguishes itself from the sibling flow case with 'This is external flow, not a pipe bore,' so the agent can tell it apart from geometry_pipe_oh without opening a 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?

Gives preconditions ('in an empty session'), downstream sequencing ('then call mesh_generate, mesh_export and openfoam_prepare'), and hard restrictions ('mesh_configure cannot override this template', 'To change its geometry or counts, create a new session'). It also states the when-not case (pipe bore), leaving little to inference.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read ('List') but does not confirm read-only semantics, does not state that an active session is required, and does not mention pagination, limits, or what happens if no geometry exists. Substantial behavioral gaps for a tool with zero annotation coverage.

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

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

A single front-loaded sentence with no wasted words. It is appropriately sized, though the extreme terseness leaves several gaps that additional sentences could have closed.

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

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

An output schema exists, so return values need not be described, but the definition still omits required session context, the meaning of 'dimension', and any usage routing among the many geometry/mesh siblings. For a 2-parameter, annotation-free tool this is under-specified.

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

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

Schema description coverage is 0% and the description explains neither parameter. The 'dimension' parameter in particular is opaque (spatial dimension? entity dimension?) and gets no clarification; session_id is only inferable from its name. The description does not compensate for the coverage gap.

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

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

States a specific verb (List) and a specific resource (bounded model entities and their geometry), plus a scoping qualifier (at the current revision). It is distinguishable from write-oriented siblings like geometry_apply or specialized ones like geometry_structured_blocks, though it never names an alternative explicitly.

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

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

There is no statement of when to use this tool versus geometry_structured_blocks, geometry_pipe_oh, mesh_inspect, or the other geometry/mesh inspection siblings. The phrase 'at the current revision' hints at a state requirement but does not tell the agent when this tool is the right choice.

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

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

With no annotations, the description carries the full behavioral burden and does much of it: it discloses the side effects (creates inlet/outlet, wall, and fluid), the empty-session precondition, and the meshing failure mode (no tetrahedral fallback). It even flags a semantic caveat about first_cell_height not being a true normal distance on a curved wall. It stops short of describing permissions, whether the operation is destructive to prior geometry, or revision 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?

Front-loads the geometry, then constraints, then the optional axial_heights note. Dense and largely waste-free, though the run-on clause about first_cell_height on curved walls is harder to parse than it needs to be.

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

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

An output schema exists so return values needn't be explained, and the description covers the geometry, units, side effects, preconditions, and a key failure mode. The remaining gap is the undocumented numeric/topology parameters (core_fraction, radial/axial cell counts) that an agent must guess at to call this correctly.

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

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

Schema description coverage is 0% across 11 parameters, so the description is the only source of meaning, and it explains only length, radius, first_cell_height, circumferential_cells, and axial_heights. axial_cells, radial_cells, core_fraction, session_id, expected_revision, and request_key are left entirely undefined, so it only partially compensates for the coverage gap.

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

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

Opens with a specific verb and resource ('Build a straight internal pipe with square core and four curved blocks') and pins the geometry (bore centred at origin, z=0 to length, metres). 'internal' implicitly distinguishes it from the sibling geometry_external_cylinder_oh, so an agent can pick correctly 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?

States prerequisites and sequencing explicitly: 'Requires an empty session, then mesh_generate'. It also gives a hard behavioral constraint ('never falls back to tetrahedra') and a validity rule ('circumferential_cells must be divisible by four'). It stops short of naming an alternative tool for the overset/external case, but the workflow context is clear.

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

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

With no annotations, the description carries the full behavioral burden and does so well: it discloses the empty-session requirement, metre units, cell-count agreement on shared edges, automatic inlet/outlet cap and fluid groups, locked counts, and no arbitrary CAD decomposition. It does not describe error behavior or all mutation side effects, so it is not exhaustive.

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

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

The purpose is front-loaded and the dense detail is necessary for a complex nested geometry recipe. The parameter-map sentence is run-on and could be structured better, but almost every sentence carries actionable 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?

Given the complex nested parameters, zero schema coverage, and no annotations, the description provides prerequisites, parameter structure, constraints, automatic behaviors, and next steps. An output schema exists, so return values need not be explained, and the remaining gap around generic session fields is minor.

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

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

Schema description coverage is 0%, so the description must compensate, and it does extensively: it explains the nested parameters object, vertices, edges with kind/vertices/cells/progression/center, faces with signed edge names, span, span_cells, patches, and span_heights. It adds syntax, constraints, and field-level meaning far beyond 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?

The first sentence gives a specific verb and resource: construct connected planar quadrilateral blocks and extrude along +Z in metres. This clearly distinguishes it from sibling geometry tools such as geometry_pipe_oh and geometry_external_cylinder_oh, which create different geometry types.

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 states prerequisites (empty session), a direct follow-up action (then call mesh_generate), and explicit alternatives for a sub-task (use mesh_layer_plan or mesh_grading_two_sided to calculate span_heights). It does not explicitly say when to choose this tool over competing geometry-creation siblings, but the geometry type makes that largely implicit.

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 bears the full behavioral burden. 'Request cancellation' hints that cancellation may be asynchronous or advisory rather than immediate, but the description never confirms whether it is idempotent, what happens for an already-completed/unknown job, whether permissions are needed, or whether the request can be rejected.

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 filler. It is appropriately terse, though the terseness comes at the cost of the missing behavioral and parameter detail scored elsewhere.

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

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

An output schema exists, so return values need not be described. But for a state-mutating job-control tool with no annotations and no parameter documentation, the description should say whether cancellation is immediate or a request, and whether it can fail against finished jobs. It leaves too much undefined.

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 single job_id parameter, but it says nothing about its format or where to obtain it (e.g., from mesh_generate or job_get). A bare string identifier with zero documentation on either side is a real gap.

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

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

States a specific verb (cancel) and resource (meshing job), which is unambiguous on its own. However, it doesn't distinguish itself from sibling job_get or clarify the scope of 'meshing job' relative to the broader job family, so it stops short of a 5.

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

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

No guidance on when to cancel versus inspect a job first, no prerequisites (e.g., must the job be actively running?), and no mention of the sibling job_get tool that would surface a cancellable job_id. The agent must infer usage entirely.

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 implies a non-blocking read (polling), which is useful, but says nothing about terminal states, error behavior for an unknown job_id, polling cadence, or whether it is read-only. For a job-status tool this is 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?

One short sentence with no filler, which is well front-loaded. But it is sparse to the point of under-specification rather than genuinely efficient communication.

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

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

An output schema exists, so return values need not be described, but the missing parameter semantics and polling mechanics (frequency, terminal states, failure modes) leave real gaps for a tool whose whole purpose is repeated invocation.

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

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

Schema description coverage is 0% and the single parameter job_id has no description in either the schema or the description text. The agent gets no format, source, or validity information for the required argument.

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 plausible verb+resource ("Poll a meshing job") and hints at asynchronous behavior with "without waiting for the native mesher." However, it does not clearly differentiate from job_cancel or explain what a poll returns, leaving the purpose only partially 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?

There is no explicit when-to-use guidance: it never says whether to call this after mesh_generate, how often to poll, or when to switch to job_cancel. The only hint is the implicit contrast with blocking on the native mesher.

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 already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds the behavioral trait of pagination and the scope of record kinds, which is useful additional context beyond the structured annotations.

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

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

A single, front-loaded sentence with no wasted words. The verb and resource lead, and the enumeration of kinds is compact.

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 low-complexity, has rich annotations, and has an output schema, so return values need not be described. However, the description lacks usage guidance and fails to explain the query parameter, leaving gaps for an agent trying to call it correctly.

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

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

With 0% schema description coverage, the description must compensate for all four parameters. It partially compensates by enumerating possible kind values and implying limit/offset through 'pagination', but it does not explain the query parameter at all and provides no syntax or format details for limit/offset.

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 ('records'), and enumerates the record kinds (manual, api, option, source, guide, capability), making the tool's purpose clear. However, it does not explicitly differentiate itself from sibling tools like knowledge_search, which could also be used to find records.

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

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

The description provides no guidance on when to use this tool versus alternatives such as knowledge_search or knowledge_read. It only implies usage by saying it lists catalog records with pagination, but gives 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so safety is covered. The description adds useful context: the result includes provenance and pagination is by character offset, which goes beyond the annotations.

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

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

A single, front-loaded sentence with zero wasted words. It communicates the core action and key behavioral traits efficiently.

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

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

For a 3-parameter read tool with no schema descriptions, the description is too sparse. It omits required parameter semantics (document_id), default values, and any usage context relative to siblings like knowledge_search.

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

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

Schema description coverage is 0%, so the description must compensate. It only implies that offset and limit refer to character positions, but does not describe the required document_id, the default limit of 12000, or the maximum bound.

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 'bounded document excerpt', with add-ons 'provenance' and 'character-offset pagination' that make the scope clear. It does not name siblings, but the purpose is unambiguous.

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

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

No when-to-use guidance is provided. There is no mention of alternatives like knowledge_search, nor any conditions that would select this tool over its siblings.

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

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

Annotations already cover readOnly, idempotent, non-destructive, and closed-world properties. The description adds modest value with 'Search is local and bounded', but says nothing about result format, ranking, or what pagination behavior to expect beyond what the schema implies.

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

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

Two short, front-loaded paragraphs with no filler; the core action leads. The second paragraph is somewhat oblique, but the overall shape is tight.

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

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

An output schema exists, so return values need not be described. However, with four undocumented parameters and no routing guidance against three similarly named knowledge_* siblings, the description leaves meaningful gaps 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?

Schema description coverage is 0% across 4 parameters, so the description carries full burden. It never explains what 'kind' filters, and gives only incidental hints about query/limit/offset. The 'read hits by ID' phrasing further muddies parameter intent rather than clarifying it.

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: search across 'manual, API, option, source, guide or capability documents'. That is clear and distinguishable from most siblings, though the appended clause 'read hits by ID' overlaps with the sibling knowledge_read and blurs which tool actually retrieves a hit.

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

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

It gives context ('Search is local and bounded') and a caution about documented upstream functions not being executable tools, but never states when to use this versus knowledge_read, knowledge_catalog, or knowledge_status. Usage is implied rather than specified.

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 already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds that output includes runtime mismatch warnings, which is useful behavioral context beyond the annotations, but it does not elaborate on triggering conditions or severity of those warnings.

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 well-packed sentence with no filler and the key content listed up front. Every phrase 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 parameterless read-only tool with an output schema, the description is nearly sufficient: it names what the report contains, and the output schema handles return-value detail. Only the timing/context of when to call it 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?

The tool takes zero parameters and schema coverage is 100%, so the baseline of 4 applies. There is nothing for the description to clarify on the parameter axis.

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

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

States a specific verb ("Report") plus four concrete resources: documentation versions, provenance, availability, and runtime mismatch warnings. This clearly separates it from the content-oriented siblings (knowledge_search/read/catalog), though it never names or explicitly contrasts with them.

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

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

Usage is only implied: an agent can infer this is a diagnostic/status check to run before or alongside the knowledge content tools. There is no explicit when-to-use, no prerequisites, and no stated alternative, so it stays at the implied-usage level.

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. 'Set' implies a write/configuration operation, but the description does not disclose permission requirements, revision/idempotency behavior for expected_revision and request_key, or side effects.

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

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

The description is brief and front-loads the main purpose. However, the second clause 'tetrahedral meshing is explicit' is ambiguous and does not clearly 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?

For a 9-parameter configuration tool with no annotations and no schema parameter descriptions, the one-sentence description is far too incomplete. It omits usage context, parameter semantics, and mutation behavior, leaving the agent with insufficient information to invoke it correctly.

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

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

The schema has 9 parameters with 0% description coverage, including required concurrency fields (session_id, expected_revision, request_key). The description does not explain any parameter meaning, formats, or interactions, so it fails to compensate for the schema gap.

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

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

The description states a specific verb and resource: 'Set structured single-box hex controls.' It also distinguishes the scope from tetrahedral meshing, which helps separate it from general mesh-generation tools, even though it does not name a particular sibling 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?

There is no explicit when-to-use guidance, no prerequisites, and no named alternative tool. The clause 'tetrahedral meshing is explicit' is too cryptic to serve as clear routing advice.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it only characterizes the output format (ASCII, first-order, MSH 2.2). It says nothing about side effects, where the export is written, permissions, or how session_id and expected_revision gate the operation.

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

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

A single front-loaded sentence with zero filler; the verb and output artifact lead. It is efficiently written, though arguably undersized for a four-parameter tool with a session/revision contract.

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

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

An output schema exists, so return values need not be described, but the three required parameters, the session precondition, and the concurrency semantics of expected_revision are all absent. For a tool this structured, the description is too thin.

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

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

Schema description coverage is 0%, so the description must compensate, but it only loosely corresponds to the 'format' parameter ('MSH 2.2' vs default 'msh2'). The three required parameters (session_id, expected_revision, request_key) are left entirely unexplained, which is a significant gap at 0% 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?

States a specific verb ('Export') and resource ('classified first-order ASCII MSH 2.2'). The purpose is unambiguous, but it does not differentiate itself from siblings like openfoam_convert or mesh_generate, and 'for OpenFOAM conversion' could be read as overlapping with the conversion tool's role.

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?

'For OpenFOAM conversion' implies this export is a preparatory step before converting, giving weak workflow context. However, there is no explicit when-to-use, when-not-to-use, or named alternative, leaving the agent to infer the sequencing.

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 add two useful behavioral facts: the job is 'durable' and the call returns immediately with a job ID, implying an async pattern. However, it omits mutation/side-effect disclosure, permission needs, and the meaning of expected_revision/request_key for conflict and idempotency behavior.

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

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

A single front-loaded sentence with no filler; the essential action and the immediate-return behavior are stated first. Nothing is wasted.

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

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

For a four-parameter, annotation-free job-start tool with revision and idempotency keys, one sentence is insufficient. The output schema covers the return value, but the description omits prerequisites, conflict/stale-revision behavior, and request_key deduplication semantics that an agent needs to call it correctly.

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

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

Schema description coverage is 0% across four parameters, so the description must compensate, and it mentions none of them. session_id, expected_revision, and request_key are critical required inputs whose semantics (concurrency control, idempotency) are left entirely unexplained, as is the optional dimension.

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: 'Start a durable meshing job', and adds the key behavioral outcome 'return its job ID immediately'. It is clearly the async job-start operation in the mesh_* family, though it does not explicitly name or differentiate itself from siblings like mesh_configure or mesh_grading_calculate.

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 mesh_configure, mesh_grading_*, or when to prefer synchronous alternatives, nor any mention of prerequisites such as an active session. The phrase 'Start a durable meshing job' only implies usage; it does not state when/when-not or point to the follow-up tool (job_get).

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 already cover read-only, idempotent, and non-destructive safety properties. Beyond that, the description adds useful behavioral context: it returns cell heights, positions, actual adjustments, and mesh_configure arguments, and it explains that strict mode rejects incompatible constraints while adjust modes preserve specific values. It still leaves error behavior and axis/divisions handling vague.

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 dense but appropriately sized for an eight-parameter calculation tool, and it is front-loaded with the core purpose. Each sentence adds constraints, modes, or output behavior that an agent needs, with no 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?

Because an output schema exists, the description need not fully explain return values, though it helpfully summarizes them. For a complex eight-parameter tool with 0% schema description coverage, it is incomplete: axis and divisions are entirely undocumented, and the valid fit values are only partially enumerated.

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

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

Schema description coverage is 0%, so the description must compensate, and it does for several parameters: length, cells, first_cell_height, growth_ratio, direction, and the fit modes strict, adjust_ratio, and adjust_first_height. However, axis and divisions receive no semantic explanation at all, leaving two of eight parameters opaque despite the zero schema 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 specific verb and resource: 'Calculate structured geometric grading in metres.' It clearly distinguishes this from mesh_generate and mesh_configure by explaining that it returns configuration arguments and does not alter a session, but it never explicitly contrasts itself with the sibling mesh_grading_two_sided, so sibling differentiation is incomplete.

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

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

It gives clear usage context: supply length plus at least two of cells, first_cell_height, and growth_ratio, and then apply the returned arguments and call mesh_generate. It also states that the calculation does not alter a session or generate a mesh by itself. However, it does not explicitly say when to choose this tool over mesh_grading_two_sided.

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 already declare the operation read-only, idempotent, and non-destructive. The description adds meaningful context beyond that: returned node positions and normalized extrusion heights are exact planning data, no native mesh is changed or certified, and odd counts require symmetric wall inputs with one center cell. It does not cover auth or rate-limit behavior, but its added planning-vs-mutation clarification is valuable.

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 tightly packed and front-loaded: it begins with the core action, then covers fit modes, edge-case geometry, and return semantics in four short sentences. There is no observable 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?

The output schema exists, so return values need not be fully explained, and annotations cover the safety profile. Still, with zero schema descriptions across seven parameters, the description should carry more parameter-level meaning than it does; it partially compensates by explaining fit modes and odd-count constraints, but important inputs remain opaque.

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 tool has seven parameters. The description hints at the fit modes and symmetric wall-input requirement for odd counts, but it does not map meanings to growth_ratio, opposite_growth_ratio, opposite_first_cell_height, length, cells, or first_cell_height, leaving most parameter semantics undocumented.

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

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

The description states a specific action and target: planning ordered wall-to-wall cell heights over a fixed length. It is clear enough to distinguish from generic mesh operations, but it does not explicitly contrast itself with the sibling mesh_grading_calculate or other mesh planning 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 explains the behavior of the fit modes (default, strict, adjust_first_height), which implies when each mode is appropriate. However, it gives no explicit when-to-use guidance relative to sibling tools such as mesh_grading_calculate or mesh_layer_plan.

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 already declare readOnly, idempotent, non-destructive behavior, so the bar is lower. The description still adds real value beyond them: bounded paging, the stale-revision failure mode ('fail instead of mixing different meshes'), the 1..1000 limit range, and the dimension=-1 sentinel.

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 terse sentences, each carrying distinct information, with the core read scope front-loaded and constraints (revision, limits, dimension) packed into single clauses. No filler.

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

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

An output schema exists, so return shape need not be explained, and the description covers scope, paging discipline, and revision consistency. It is close to complete for a read/pagination tool, with only the offset and session parameters left to the schema's bare titles.

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 defines the limit bounds and dimension=-1, but never explains expected_revision's type/source, session_id, or the node_offset/element_offset paging semantics beyond the generic word 'pages'.

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: reading bounded node/connectivity pages and counts from a mesh. 'completed mesh' scopes it relative to mesh_generate/mesh_configure, though it never names a sibling to route between mesh_inspect, mesh_quality, and geometry_inspect.

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?

'from the completed mesh' implies the prerequisite that a mesh must already exist. The instruction to retain expected_revision across pages is genuine usage guidance for pagination, but there is no explicit when-to-use/when-not or alternative-tool routing.

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 already declare readOnly/idempotent/non-destructive, so the safety profile is covered. The description goes beyond them with the key caveat that 'the result is a plan, not evidence that Gmsh created or validated the requested layers' and with the per-fit behavior (strict rejects inconsistent inputs; adjust_ratio preserves first height and count; adjust_first_height preserves count and ratio) — genuinely useful traits not present in structured 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?

Dense and front-loaded: the lead sentence states purpose and scope, then parameters, then fit behavior, then the plan-vs-validation caveat. Every sentence carries information and nothing is redundant.

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

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

With an output schema present, return values need not be described, and the description appropriately focuses on input constraints, fit-mode behavior, and the caveat that output is a plan. It is nearly complete, though it omits units and does not explicitly differentiate itself from the grading siblings.

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

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

Schema description coverage is 0%, so the description must carry the parameter burden, and it largely does: it names first_cell_height, cells, growth_ratio, thickness, and fit, and explains the preservation semantics of each fit value (including values not enumerated in the schema). It is missing units and the meaning of the 1–256 cell bound, so it is not fully compensating.

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

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

The description states a specific verb+resource ('Plan one-sided geometric wall layers') with an explicit scope qualifier ('without modifying a model'), so an agent immediately knows this is a read-only planning/compute call rather than a model mutation. It hints at the downstream consumer (structured block extrusion) but does not directly name or contrast a sibling such as mesh_grading_calculate or mesh_grading_two_sided.

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 supplies a concrete precondition: 'Supply first_cell_height plus at least two of cells, successive-cell growth_ratio and total thickness', and explains when each fit mode applies (strict rejects, the adjust modes preserve different quantities). This is clear usage context, but it never names an alternative tool or states when NOT to use this one versus the mesh_grading siblings.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the safety profile is covered. The description adds genuinely non-structured behavior: cells at or below threshold fail, the failure list is bounded, and counts/coverage describe the complete mesh even when the list is truncated, which is valuable operational context.

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

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

Front-loaded with the core purpose, followed by metric and threshold guidance, then failure semantics. Sentences are dense and mostly earn their place, though the metric/threshold notes could be slightly tighter.

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 annotations cover the safety profile. The description adds metric and failure-truncation semantics, leaving it largely complete for correct invocation despite the undocumented required params.

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 0% schema description coverage the description must carry the burden, and it partially does: minSICN vs minDetJac semantics and threshold scaling are explained, and 'failure list is bounded' implies the failing_limit behavior. But session_id, expected_revision, and histogram_bins remain undocumented in both schema and text.

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 (evaluate), resource (all volume cells) and output (quality statistics/histogram and worst failures). It further distinguishes itself from the OpenFOAM sibling by explicitly noting 'This is Gmsh quality, not OpenFOAM checkMesh', so an agent can route between mesh_quality and the openfoam_* tools 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 description gives real guidance on selecting a threshold per metric ('choose its threshold for the model scale') and on failure semantics, which is usable context. However, it never states when to prefer this tool over siblings such as mesh_inspect or when a quality check is warranted versus not, so usage is only 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?

With no annotations, the description carries the full burden. It does disclose two behaviors: it creates a new staged case and runs checkMesh. It omits failure behavior (what happens if checkMesh fails), whether the source export is modified, permission needs, and any rollback semantics.

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

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

A single front-loaded sentence with no filler; the action and its immediate side effect come first.

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 as an unannotated, two-parameter pipeline step, the definition omits when to invoke it relative to openfoam_prepare/inspect and what the parameters mean, leaving real gaps.

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

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

Schema description coverage is 0%, yet the description adds no meaning for session_id or export_manifest_path. Only a weak hint exists that the manifest must be 'verified'. Both required parameters are effectively undocumented.

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

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

States a specific verb (Convert) and resource (a verified export into a new staged case) plus a side action (run checkMesh), so the operation is clear. However, it does nothing to distinguish itself from sibling openfoam_prepare and openfoam_inspect, leaving the agent to infer the pipeline position.

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

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

No explicit when/when-not or named alternatives among the openfoam_* siblings. The adjective 'verified' implies a precondition (the export must already be verified) but this is left implicit rather than stated as a rule.

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 entire behavioral burden. 'Audit' and 'inspect' imply a read-only operation, but the description never confirms this, nor does it mention side effects, required permissions, or the relationship between session_id and the stored export.

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, which is ideal for scanning. It is arguably undersized for a three-required-parameter tool, but no sentence is wasted.

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

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

The output schema exists, so return values need not be described. However, with no annotations and fully undescribed required parameters, the description omits the operational context an agent needs: how the export manifest is produced, what the session must contain, and how this differs from the sibling inspection 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?

All three required parameters (session_id, export_manifest_path, case_dir) have 0% schema description coverage, so the description must compensate and does not. It never explains the role of the manifest versus the case directory, leaving the distinction between export_manifest_path and case_dir entirely to inference from parameter names.

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

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

States a specific verb ('Audit') and enumerates the resources inspected: polyMesh addressing, names, geometry and patch ranges. This is far more concrete than a tautology, but it offers no differentiation from siblings like mesh_inspect, geometry_inspect, or openfoam_probe, which an agent must distinguish by name 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 when-to-use guidance, no stated prerequisites, and no mention of alternatives such as openfoam_probe or mesh_inspect. The agent must infer from the word 'stored' that this operates on previously exported mesh data rather than a live case.

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

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

With no annotations, the description carries full behavioral burden. It implies a read-only verification but does not explicitly state whether files are modified, what permissions are needed, or what happens on failure. The name 'prepare' adds ambiguity that the description does not resolve.

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

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

A single front-loaded sentence with no wasted words. It is efficiently structured, though arguably too terse given the tool's complexity and lack of supporting 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?

The tool has no annotations, no parameter descriptions, and an output schema (which reduces return-value burden). However, the description does not cover prerequisites, what a successful or failed verification means, or how to interpret the manifest, leaving significant gaps for a verification step in a multi-tool workflow.

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

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

Schema description coverage is 0% for two required parameters, and the description does not explain session_id or export_manifest_path. The listed verification items may relate to manifest content, but no explicit connection is made.

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 ('Verify') and resources (MSH2 cells, patch names, geometry, exterior face coverage). It is clear what the tool checks, but it does not explain how it differs from sibling validation tools like openfoam_inspect or patch_validate.

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. There are no prerequisites, no indication of when it should be called in a workflow, and no exclusions.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not state that this is a read-only, side-effect-free discovery operation, nor whether it requires the server to have a configured OpenFOAM install, nor what happens when none is found. 'Probe' hints at non-mutation but the description never confirms it.

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

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

A single efficient sentence with no filler, and the core notion (target of the probe) is front-loaded. It is appropriately brief for a no-argument tool, though it is arguably under-specified rather than maximally tight.

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

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

With no parameters and an output schema present, the description need not explain return values, so the structured data carries most of the load. What is missing is the usage relationship to the other openfoam_* siblings and any behavioral framing, which is the main remaining gap for this otherwise simple tool.

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

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

The tool takes zero parameters, so the baseline is 4. There is nothing for the description to clarify beyond the empty schema, and it correctly implies the operation is configured entirely server-side.

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 (probe) and resources (the server-configured OpenFOAM distribution and converter commands), so the purpose is broadly identifiable. However, 'probe' is vague about what is actually discovered or returned, and there is no differentiation from the adjacent openfoam_prepare, openfoam_convert, and openfoam_inspect siblings. It reads as adequate-but-thin rather than 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?

There is no statement of when to call this tool versus the sibling openfoam_* tools, no prerequisites, and no exclusions. An agent must infer that 'probe' is a discovery/status step likely run before prepare or convert. No explicit guidance is offered.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not disclose that this is a mutating operation, that the operation is concurrency-guarded (expected_revision, worker_epoch) or idempotent (request_key), or what happens on a revision conflict. For a 9-parameter write tool this is a significant gap.

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

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

A single sentence with no filler and a front-loaded action, but it is under-specified rather than genuinely concise – the brevity comes at the cost of the parameter and behavioral detail an agent needs.

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

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

An output schema exists, so return values need not be explained. However, for a mutation tool with 9 undocumented parameters, no annotations, and hidden concurrency semantics, the one-line description leaves out information the agent needs to invoke it correctly.

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

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

Schema description coverage is 0% across 9 parameters. The description only maps loosely to three of them (name, surface_tags via “surfaces”, mesh_type via “patch type”) and says nothing about role, physical_id, session_id, expected_revision, request_key, or worker_epoch, which are the non-obvious concurrency and identity fields.

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 pair (“Name”, “assign”) and a concrete resource (exterior surfaces / OpenFOAM mesh patch type), so an agent can tell it apart from inspection or validation siblings like mesh_inspect or patch_validate. It stops short of explicitly naming or contrasting with those siblings, which keeps it off a 5.

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

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

There is no guidance on when to call this versus patch_validate, mesh_configure, or physical_volume_set, and no stated prerequisites (e.g. an active session, a prior mesh). The only implicit context is that surfaces must already exist.

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 almost nothing. It does not say whether this is a read-only check, whether it blocks or gates the export, what a failed validation means, or how exhaustive the coverage check is.

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, fully front-loaded with the action and the resource. No filler or 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?

An output schema exists, so return values need not be explained. What remains missing is behavioral context: no annotations and no statement of read-only nature or gating behavior leaves an agent unable to predict the tool's side effects.

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

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

Schema description coverage is 0%, but the single parameter is a self-evident session_id, which needs no syntax or format explanation. The description adds nothing about it, which is acceptable only because the parameter is a universally understood session handle.

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 ('Check named patch coverage') that a reader can distinguish from mesh_quality and mesh_inspect. It is clear but does not explicitly contrast itself with those adjacent validation siblings.

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

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

The phrase 'before exporting a CFD mesh' implies a usage window, giving a temporal context. However, it names no alternatives (e.g. mesh_quality, mesh_inspect) and states no condition for when this check is required versus optional.

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 none of the mutation semantics: whether this overwrites prior classifications, what expected_revision guards, whether request_key implies idempotency, or what worker_epoch means. Only a faint indication that it mutates state 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, which is efficient. It is terse to the point of under-specification rather than padded, so its brevity is not wasteful.

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 (relieving the description of return-value explanation), this is a 7-parameter state-mutating tool with no annotations and no documented parameters. The description leaves far too much unspecified for an agent to call it safely and correctly.

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

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

Schema description coverage is 0% across 7 parameters, and the description documents none of them. Critical inputs like expected_revision, request_key, worker_epoch, and volume_tags are left entirely opaque, so the description fails to compensate for the schema gap.

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

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

The description gives a verb ("Classify") and a resource ("retained fluid volume cells") scoped by "a named physical volume," which is somewhat specific but sits oddly against the tool name physical_volume_set (set vs classify). It does not differentiate from any sibling, and the domain concept is left unexplained.

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

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

No when-to-use guidance, no prerequisites, and no mention of any alternative tool. The agent is given only a purpose statement with no context for deciding whether this is the right call.

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

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

With no annotations, the description carries the full burden, but it does disclose the concrete effect: the owned viewer and model worker are terminated. It does not say whether the close is idempotent, whether it releases server-side state, or whether it requires ownership/permissions beyond the word 'owned'.

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, stating the action and its scope immediately. It is appropriately sized for a simple teardown tool, though it is perhaps too terse given the gaps elsewhere.

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

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

An output schema exists, so return values need not be explained, and the one-parameter surface is small. However, for a destructive mutation with no annotations, the description omits preconditions, side effects on related state, and parameter provenance, leaving meaningful gaps.

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

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

One required parameter with 0% schema coverage, so the description must compensate and it does not – session_id's format, origin (from session_create/session_status), or validity conditions are never described. The term 'session' only loosely ties the parameter to the 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 gives a specific verb (close) and names the two resources torn down (owned viewer and model worker), which is more informative than 'close a session'. It stops short of distinguishing itself from the sibling view_close, which an agent could easily confuse it with.

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

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

There is no statement of when to use this tool versus view_close or when session teardown is appropriate (e.g., after a job completes). Nothing tells the agent about preconditions or the alternative of closing only the viewer.

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 disclosure burden. 'Isolated Gmsh worker' hints at process isolation but says nothing about resource cost, whether the session must later be closed, what happens on failure, or any permission requirements for a state-creating 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?

One front-loaded sentence with no filler, so nothing is wasted. However, it is thin to the point of under-specification rather than genuinely efficient, which caps the score at adequate.

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 creation tool with zero annotation coverage and 0% parameter documentation, the description should at minimum cover session lifecycle expectations and parameter meaning. It leaves both gaps 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?

Schema description coverage is 0%, so neither 'name' nor 'units' is documented anywhere. The description does not say what 'name' identifies (a project, a mesh model, a display label) or what unit values are legal beyond the schema's 'm' default, leaving the agent to guess.

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

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

States a specific verb ('Create') and resource ('model session'), plus the side artifact ('isolated Gmsh worker'), which distinguishes it from sibling lifecycle tools like session_status and session_close. The term 'isolated Gmsh worker' is jargon an agent may not fully decode, keeping it from a 5.

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

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

No statement of when to call this versus session_status/session_close, no prerequisites, and no indication of what must exist before a session can be created. An agent can infer ordering from the lifecycle siblings, but the description provides no explicit guidance.

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

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

With no annotations, the description must carry behavioral disclosure. It does add that the state is 'cached' and can be read while meshing continues, suggesting a non-blocking read-only operation. It does not disclose permissions, side effects, or whether the state is live versus stale beyond the word 'cached'.

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 redundant or filler text. It is appropriately sized for a simple status 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?

The tool is simple, has an output schema, and only one required parameter. The description covers the basic operation but leaves gaps around parameter meaning and sibling differentiation. It is minimally adequate rather than 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 has 0% description coverage and one required parameter, session_id. The description does not mention or explain the parameter at all, so it fails to compensate for the missing schema documentation.

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

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

The description names a specific verb ('Read') and resource ('cached session and viewer state'), and adds a useful condition ('while meshing continues'). It does not explicitly differentiate itself from siblings like view_status or session_create, but the core purpose is clear.

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

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

It gives a timing context ('while meshing continues'), which implies when the tool is useful. However, it does not name alternatives such as view_status or session_close, nor does it state when not to use it.

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

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

There are no annotations, so the description carries the disclosure burden; "Report" implies a read-only, side-effect-free operation, but this is never stated explicitly. For a zero-argument informational tool with an output schema, there is little behavioral surface to cover, so a minimal-but-adequate 3 is fair.

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 subject of the report is stated immediately after the verb. Nothing to trim and nothing buried.

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 that documents the returned capability fields, the description does not need to enumerate return values. It is complete enough to call correctly, only missing the when-to-use framing and an explicit read-only statement.

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

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

The tool takes zero parameters, which is the baseline-4 case. The description correctly implies no inputs are required and names the categories the report covers (broker, native, OpenFOAM), consistent with 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 ("Report") and a concrete resource (installed broker plus native/OpenFOAM capabilities), so the agent knows it is an introspection tool. It does not, however, distinguish itself from adjacent status/reporting siblings such as session_status or openfoam_inspect, leaving some ambiguity about which reporting tool to pick.

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

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

No when-to-use guidance is given: the description never says when a capability check is warranted or how it relates to openfoam_probe/openfoam_inspect. The agent must infer the trigger condition from the name alone.

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

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

No annotations are provided, so the description carries the full disclosure burden. It reveals that a file artifact is produced, but says nothing about permissions, whether an existing artifact is overwritten, or what must be true beforehand (a session and a displayed checkpoint). For a write/artifact-creating tool this is 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?

A single tight sentence with the action and destination front-loaded and no filler. Nothing could be removed without losing information, and length is well matched to a one-parameter tool.

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

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

An output schema exists, so return-value explanation is not required, and the artifact destination is stated. However, preconditions (an active session, a displayed checkpoint) and any overwrite behavior are left implicit, which matters because there are no annotations to fall back on.

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 single session_id parameter is undescribed in both schema and description. The description does not explain what session_id identifies or whether it must match an open session, so it fails to compensate for the coverage gap.

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

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

States a specific verb (Write) plus a specific artifact (native PNG of the displayed checkpoint) and the destination (session artifacts). The scope is unambiguous, though it never names or contrasts with the sibling view_clip, which sounds like a closely related view-image 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?

'On-demand' implies this is invoked by explicit request rather than automatically, which gives a weak usage cue. There is no statement of when to prefer this over view_clip or other view_* siblings, and no prerequisites or exclusions are given.

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

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

Annotations already declare readOnly=false, idempotent=true, and destructive=false. The description adds that it affects only the live viewer, preserves camera and mesh revision, and persists through checkpoints, which is valuable behavioral context; it does not cover auth or rate limits.

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?

Four short sentences, front-loaded with purpose, each adding distinct information (retention semantics, disabling, side effects). No 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?

Output schema exists, so return values need not be described, and annotations cover the safety profile. The description covers important side effects and key parameter behavior, though it leaves some schema details (axis, session_id) undocumented.

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

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

Schema description coverage is 0%, so the description must compensate. It explains keep (positive/negative retention), enabled=False disables clipping, and position in metres, but leaves axis enum semantics and session_id unaddressed, so compensation is only partial.

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 ('Clip') and resource ('displayed model') and scope (global coordinate plane in metres). It does not distinguish this from sibling view tools such as view_set or view_capture, 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?

Implies usage by describing what clipping does and that enabled=False disables it, but gives no explicit when-to-use guidance versus view_set, view_capture, or other view tools. Adequate minimum, but no alternatives 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?

With no annotations, the description carries the full behavioral burden. It usefully discloses that the model session survives the close and that only the 'owned' viewer is affected, but says nothing about error cases (viewer not open), idempotency, or confirmation semantics.

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

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

One sentence with the action and the key side-effect front-loaded; every word earns its place and nothing is repeated from the schema.

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

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

For a one-parameter teardown tool with an output schema present (so return values need not be described), the description covers the essential behavior and the critical side-effect distinction. Only edge-case behavior is left unstated.

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

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

Schema description coverage is 0%, so the description must compensate, and it does not mention session_id at all. The single required param is fairly self-evident, but 'owned' is the only clue tying the viewer to the session and it is not elaborated.

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 owned native viewer') and adds the outcome qualifier 'preserving the model session', which implicitly distinguishes it from session_close. It never names the 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?

The phrase 'preserving the model session' implies the intended scenario (tear down the viewer without ending the session), which hints at when to prefer this over session_close. However, there is no explicit when-to-use statement, no prerequisites, and no exclusion of 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?

With no annotations, the description carries the full burden. 'Owned native Gmsh GUI' hints at an app-managed process, but nothing is said about side effects of launching a GUI, behavior if one is already open, display/headless requirements, permission needs, or whether the call is blocking.

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

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

A single tight sentence with the action front-loaded and no filler. Slightly jargon-y ('owned native') without explanation, but nothing is wasted.

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

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

An output schema exists so return values need not be described, and the 'validated checkpoint' precondition is stated. However, for a tool that spawns a GUI process with no annotations and no parameter docs, the remaining behavioral and usage gaps leave it only minimally 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?

One parameter (session_id) at 0% schema description coverage, so the schema adds nothing beyond the name. The description does not explain the session_id at all, though the name is self-explanatory and consistent with sibling tools.

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 verb and resource ('Launch the owned native Gmsh GUI') plus what it renders ('latest validated checkpoint'), which is more specific than a bare 'view' tool. It is reasonably distinguishable from view_capture/view_set/view_close, though it never names them to sharpen the boundary.

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

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

There is no when-to-use guidance and no explicit alternatives among the crowded view_* sibling cluster (view_status, view_capture, view_set, view_clip). The only usable signal is the implicit precondition that a validated checkpoint must already exist.

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?

Beyond the annotations, it discloses that this does not touch geometry or mesh and does not increment the authoritative session revision, plus the checkpoint precondition. It does not address error behavior when no checkpoint exists or any concurrency concerns, but the safety profile is well covered.

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?

Four tight sentences, front-loaded with the action and its non-effects; the enum mapping and fit semantics each earn their place with no 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?

With an output schema present, return values need not be described, and the description covers preconditions and side-effect scope. Minor gap: no mention of what happens if the viewer has no displayed checkpoint or how the change interacts with other view tools.

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

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

Schema description coverage is 0%, so the description must carry the semantics, and it does: every preset enum value is mapped to a viewing direction and fit is defined in terms of orthographic projection plus pan/zoom reset. Only session_id is left unexplained, though it is self-evident.

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

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

The description gives a specific verb+resource (select a camera preset in the Gmsh viewer) and immediately delimits scope (without changing geometry or mesh), which cleanly separates it from view_clip, view_open, and view_capture.

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 states the selecting conditions for fit=True vs fit=False and gives a precondition (a displayed checkpoint must exist), so the agent knows when each mode applies. It stops short of naming alternative sibling tools for related view operations.

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. The word "Read" implies a non-mutating operation and it enumerates the three fields returned, which is useful. However it says nothing about permissions, session requirements, or freshness/refresh behavior, which matters for a status tool.

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

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

A single efficient sentence with the verb and returned content front-loaded and no filler. It could not be trimmed further without losing the field list.

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 is not obligated to explain return formatting, and it is correspondingly brief. The gap is the required session_id, which is neither described nor explained anywhere, leaving the definition only just adequate for invocation.

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

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

Schema description coverage is 0% and the description makes no mention of session_id, so the single required parameter is undocumented in both places. The description adds no meaning about what session the status belongs to or how to obtain a valid id.

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 ("Read") with a clearly named resource set: GUI heartbeat, displayed revision, and last snapshot load time. That distinguishes it from mutation or capture siblings like view_set and view_capture, though it never explicitly names a sibling to route against.

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

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

There is no when-to-use or when-not-to-use guidance, no mention of prerequisites, and no reference to alternatives such as session_status or system_capabilities. The agent is left to infer the context 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.