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

With no annotations provided, the description carries the full burden of disclosing side effects, safety, and behavior. It only says 'run checkMesh and return a quality summary,' but does not state whether it modifies files, requires an existing mesh, or what happens on failure.

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

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

The description is a single, clear sentence with no redundant words. It is front-loaded with the verb and outcome. While minimal, it is appropriately concise for such a simple tool, though not as short as a tautology.

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 simplicity of the tool, the description is still incomplete. It does not mention when to use it, whether the mesh must already exist, or what 'quality summary' entails. An output schema exists, so return details are not needed, but the description lacks enough context for safe and correct invocation.

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

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

The input schema has one required parameter, case_name, with no description. The tool description does not elaborate on this parameter at all. Schema description coverage is 0%, and the description does not compensate.

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

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

The description clearly states the tool runs checkMesh and returns a quality summary, providing a specific action and output. It is unambiguous and can be distinguished from sibling tools like generate_mesh or summarize_results.

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

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

The description gives no guidance on when to use this tool, what prerequisites exist (e.g., a mesh must be generated first), or how it compares to alternatives. There is no mention of 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?

With no annotations, the description carries the full burden. It discloses the destructive action, specifies what is kept, and states the confirm=true requirement. However, it does not mention irreversibility, what happens if confirm is false, or any error behavior.

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

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

The description is two concise sentences with no fluff. The main action and preserved directories are front-loaded, and the confirmation requirement is stated clearly.

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, and an output schema exists, so return values need no explanation. The description covers the main effect, preserved paths, and confirmation flag. It could note irreversibility or how this differs from delete_case, but it is largely complete for its scope.

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 adds meaning to the 'confirm' parameter by requiring true, but 'case_name' is left self-evident from the tool name. This is partial but not full compensation for the missing schema descriptions.

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

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

The description clearly states the action ('Remove time directories and post-processing output') and the resource, while listing what is preserved ('0/, constant/, system/'). This distinguishes it from sibling tools like delete_case, which would remove the entire case.

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

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

The description implies when to use (cleaning a case after simulation/post-processing) but does not explicitly contrast with alternatives like delete_case. The confirm=true requirement is a precondition, not a usage guideline.

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 mode-specific behavior: mock mode uses an ideal parabolic profile with a 'small noise-free match', and real mode uses an MVP approach with bulk U and analytical profile as reference, with future extension possible. This is useful behavioral context, though it omits side-effect or permission details.

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

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

The description is two short paragraphs with no redundancy. The first sentence states the core purpose, and the second adds necessary mode-specific detail without wasting words.

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

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

Given a simple tool with one parameter and an output schema, the description covers the primary purpose and mode-dependent behavior. However, the missing parameter documentation and lack of explicit alternative guidance create clear gaps. It is an adequate but not fully self-sufficient description.

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

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

The input schema has only one parameter, case_name, with 0% schema description coverage. The description never explains what case_name refers to, its expected format, or valid values, leaving the agent to infer solely from the parameter name. This is a clear gap, though minimized by having only one obvious parameter.

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 opening sentence 'Compare numerical pipe flow to Hagen–Poisseuille analytical solution' is a specific verb+resource+reference statement. It clearly distinguishes this tool from sibling tools like summarize_results or export_for_paraview, which have different purposes.

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 mentions two contexts, 'In mock mode' and 'With real OpenFOAM results', providing implied guidance on when the tool behaves differently. However, it does not explicitly name alternative tools or state when to prefer this tool over siblings, so usage guidance remains only 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?

There are no annotations, so the description carries the full burden of behavioral disclosure. However, it only states that a case is created from a template; it does not disclose what happens if the case already exists, whether it copies files, requires prior steps, or what side effects occur. This is a significant gap for a mutation tool.

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

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

The description is a single, compact sentence that immediately states the tool's purpose without any filler or redundancy. It is well-structured and front-loaded, earning a full score.

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

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

Given the tool's simplicity, the presence of an output schema, and high schema coverage, the description is minimally adequate. However, it lacks context about prerequisites (e.g., selecting a template), potential name conflicts, and interaction with sibling tools like list_templates, leaving some gaps for the agent.

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

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

Schema description coverage is 100%, and the schema already explains each parameter (name, template, description) with defaults and constraints. The description adds no parameter-specific meaning beyond the schema, so the baseline score of 3 applies.

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

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

The description 'Create a new OpenFOAM case from a template' clearly identifies the action (create), the resource (OpenFOAM case), and the method (from a template). It distinguishes this tool from siblings like delete_case, clean_case, and list_cases, which serve different purposes.

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

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

The description implies usage ('Create a new...') but does not explicitly state when to use this tool versus alternatives, nor does it mention prerequisites such as listing available templates first. It provides no exclusions or alternative tool references, leaving the decision to the agent's inference from the tool name and sibling list.

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

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

With no annotations, the description carries the full burden. It clearly discloses the destructive, irreversible nature ('Permanently delete') and the mandatory confirm flag, which are the most critical behavioral traits for a deletion tool. It omits side effects or failure modes, but the disclosure is still strong.

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 concise sentences, front-loaded with the action, and every word adds value. No redundancy or 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 tool is simple, and an output schema exists, so return values are covered elsewhere. The description covers the core destructive action and safety requirement. It lacks a contrast with clean_case and potential side effects, but for a straightforward delete operation, it is nearly complete.

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

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

Schema coverage is 0%, so the description must compensate. It explains confirm must be true, adding meaning to that parameter. However, case_name is left to its self-evident name, and the behavior when confirm is false is only implied, not stated. Partial compensation.

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 ('delete') and a clear resource ('case directory'), making the action unambiguous. The word 'Permanently' adds important irreversible context and differentiates it from non-destructive operations like clean_case.

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

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

No guidance is given for when to use this tool versus alternatives like clean_case or describe_case. The only usage-related instruction is 'Requires confirm=true', which is an invocation detail, not a selection guideline.

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

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

No annotations are provided, so the description carries the full burden. It does not disclose any behavioral traits beyond the basic function, such as whether it is read-only, requires permissions, or has side effects. The read-only nature is implied but never stated.

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

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

The description is a single, front-loaded sentence that directly states the tool's purpose and key coverage areas. Every word contributes meaning, with 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?

The description is concise and covers the tool's main purpose, but given the presence of an output schema and no annotations, it could benefit from clarifying that the tool is read-only or mentioning what happens if the case does not exist. It is adequate for a simple describe operation but leaves some edge-case context unaddressed.

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

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

With 0% schema description coverage, the description must compensate for the undocumented 'case_name' parameter. It does not explain what 'case_name' should be, where to find valid values, or any formatting requirements, leaving the parameter semantics ambiguous.

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

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

The description clearly states the tool's function: 'Describe a case' and lists the specific aspects it covers (template, mesh status, parameters, latest time, solver). This distinguishes it from sibling tools like list_cases (which lists cases) and other operations.

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

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

The description implies this tool is for getting a detailed summary of a single case, as opposed to listing or modifying cases, but it does not explicitly state when to use it over alternatives or mention any 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?

With no annotations provided, the description carries the burden of behavior disclosure. It does tell the agent that the export uses foamToVTK and produces an optional zip file on disk, which is useful context. However, it omits side effects like overwriting existing files, required permissions, or whether the case is modified, leaving some behavioral ambiguity.

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: it leads with the verb and resource, then provides the method and optional zip. There is no wasted verbiage, and it is easily scannable.

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

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

Despite having an output schema, the description lacks critical contextual information: it does not say that the case must already exist or that the solver must have run, nor does it mention whether the operation is synchronous or asynchronous. For an agent to invoke this correctly, it would need to infer prerequisites from sibling tool names. This is a clear gap.

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

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

Schema description coverage is 0%, but the description still maps to the two parameters: 'case' implies case_name is the case to export, and 'optional zip package' indirectly indicates the make_zip boolean. However, it does not explicitly explain how the parameters are set or any constraints/format for case_name, so the added value is moderate.

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

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

The description clearly states the tool's purpose: exporting a case for ParaView via foamToVTK. It uses a specific verb (export), a specific resource (case), and even identifies the underlying method and optional zip output, distinguishing it from sibling tools like create_case or start_solver.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not mention prerequisites (e.g., the case must exist and have been solved), nor does it note whether this should follow start_solver or be used instead of summarize_results. Contextual cues must be inferred from the name and sibling list.

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

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

With no annotations, the description carries the full burden. It discloses the core action (running blockMesh) and the async option for background, but does not detail side effects, failure behavior, or prerequisites such as the case already existing.

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 sentences deliver the core action and the async hint without any waste. Every word earns its place.

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

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

For a simple tool, the description covers the basic operation and the async option, but it lacks explicit guidance on when to use it relative to sibling tools and prerequisites like the case needing to exist. An output schema exists, so return value details are not required, but other context gaps remain.

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

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

The description adds meaning to background by explaining it enables async jobs, which is beyond the schema's bare boolean. However, case_name is not explicitly described, though 'for the case' implies its role. Schema coverage is 0%, so the description partially compensates.

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

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

The description clearly states the tool runs blockMesh for a given case, using a specific verb and resource. This distinguishes it from sibling tools like check_mesh (which checks the mesh) and start_solver (which runs the solver).

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 mentions using background=true for async jobs, offering a conditional usage hint. However, it does not explicitly say when to use this tool versus alternatives or mention any prerequisites/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 burden. It implies a read-only operation through the verb 'get', but it does not explicitly state safety, nor does it disclose any potential limitations such as pagination, ordering, or the exact fields returned. The description is adequate for a simple read tool but lacks explicit behavioral context.

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

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

The description is a single, efficient sentence that front-loads the verb and resource, then lists the modes. It contains zero filler and earns every word.

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 and has an output schema, which covers return-value details. The description adequately communicates the two main usage modes. However, the ambiguity about parameter combinations and the scope of 'all jobs' leaves a small completeness gap, preventing a 5.

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 no parameter descriptions (0% coverage), so the description must compensate. It mentions job_id and case context, indicating that job_id targets a specific job and case_name filters jobs by case. However, it does not explain the precedence when both are provided, nor does it clarify the default 'all jobs' behavior in detail. Some meaning is added, but the full parameter logic is not spelled out.

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

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

The description clearly states the tool's function: retrieving job status by job_id, or listing jobs for a case/all jobs. It uses a specific verb and resource, and the focus on 'status' distinguishes it from sibling tools like get_logs or stop_job.

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

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

The description implies usage contexts (by job, by case, all jobs) but does not explicitly state when to prefer this tool over alternatives, nor does it provide exclusions. The purpose is self-evident, but there is no direct guidance about choosing this vs. other job-related tools.

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

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

No annotations are provided, so the description must disclose behavior. It states the output is a tail and 'filtered residual-friendly', but does not mention whether the operation is read-only, if the job must exist, or what happens for empty logs. This is insufficient for a tool with no annotation safety profile.

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

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

The description is one sentence with no extraneous words, stating the action and resource directly. Though 'filtered residual-friendly' is somewhat jargon-like, it is appropriately short and front-loaded.

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

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

Given the simple tool (2 parameters, output schema exists), the description is not complete. It lacks usage context and parameter semantics, making it hard for an agent to know when to call it and what lines does. The output schema may cover return values, but the missing guidance on job_id and lines is critical.

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 job_id (required) and lines (default 40), but the description does not explain either. 'Tail' implies lines, but it is not explicit. With 0% schema description coverage, the description should clarify parameter semantics; it does not.

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

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

The description uses a specific verb 'Return' and resource 'tail of a solver/mesh job log', clearly indicating it retrieves log output. It distinguishes from siblings like get_job_status by focusing on logs, but the ambiguous phrase 'filtered residual-friendly' prevents a 5.

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

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

No guidance is provided on when to use this tool versus alternatives like get_job_status or summarize_results. The description does not mention any exclusions or preferred contexts.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. 'List' implies a read-only operation, and the mention of 'mesh and time status' adds useful behavioral context, but it does not explicitly state safety, filtering behavior, or return format. More transparency could be provided.

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

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

The description is a single, concise sentence that front-loads the main purpose ('List CFD cases') and adds essential detail ('with mesh and time status') without any unnecessary words or repetition.

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

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

For a simple list tool with no parameters and an existing output schema, the description is adequately complete. It covers what is listed and the type of status information provided. It lacks explicit usage guidance, but the tool's simplicity and clear purpose make the description sufficient overall.

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

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

The tool has zero parameters and an empty schema, so there are no parameter details to document. The description's mention of 'workspace' indirectly indicates scope, but it does not add parameter semantics beyond the schema, which is acceptable given the baseline for zero params.

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 the specific verb 'List' and clearly identifies the resource as 'CFD cases in the workspace', adding detail about the included status fields ('mesh and time status'). This distinguishes it from siblings like 'list_templates' (templates vs cases) and 'describe_case' (single case detail vs list).

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

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

The description implies typical usage for listing cases but does not explicitly state when to use it over alternatives or mention any exclusions. It lacks comparative guidance such as 'for details on a single case, use describe_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?

No annotations are provided, so the description must convey behavior. It states a read-only list operation, which is inherently safe, but it does not disclose details such as where templates come from or whether the list is static. Minimal behavioral context beyond the name.

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

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

One sentence, front-loaded with the action, and includes a useful example. No wasted words.

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

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

Given the zero-parameter, simple nature of the tool, the presence of an output schema, and the description with an example, this is complete enough for an agent to understand and invoke the tool correctly.

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

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

There are no parameters, so the description has nothing to add to the schema. The example template name is non-parameter context. The baseline for zero parameters is 4.

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

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

Clearly states the verb 'list' and the resource 'OpenFOAM case templates', with an example ('hagen_poiseuille'). This distinguishes it from sibling list_cases, which likely lists existing cases rather than templates.

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

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

The description implies the tool is used for discovering available templates before creating a case, but it does not explicitly mention alternatives or exclusions. The context is clear, but there is no direct comparison to sibling tools like list_cases.

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

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

Annotations are absent, so the description carries the full burden. It discloses units for several parameters, which is useful, but it does not explain whether the tool overwrites all parameters, how null defaults are interpreted, or whether the case must already exist. This is a significant gap for a mutation-like tool.

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

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

The description is two sentences with no filler. The main purpose is stated first, and the units sentence provides essential context without 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?

Given 8 parameters, no schema descriptions, no annotations, and the complexity of a simulation workflow, the description is too sparse. It omits crucial context such as the requirement for an existing case, the meaning of mesh-resolution parameters, and the behavior when optional parameters are left as null. The presence of an output schema does not mitigate these 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?

The description groups parameters into categories (geometry, fluid properties, mesh resolution) and specifies units for length, viscosity, density, and velocity. However, it does not explain n_axial and n_radial beyond 'mesh resolution' and does not clarify the null-default semantics. With 0% schema coverage, the description only partially compensates.

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

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

The description clearly states the tool's action ('Set') and resource ('Hagen–Poiseuille pipe geometry, fluid properties, and mesh resolution'). It distinguishes the tool from siblings like generate_mesh and start_solver, though it does not explicitly mention that parameters are set on an existing case.

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 the tool relative to its siblings, e.g., after creating a case and before generating a mesh. It also does not mention any prerequisites or alternatives.

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

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

With no annotations, the description carries the behavioral burden. It usefully discloses that the solver runs as a background job and returns a job_id immediately. However, it omits side effects (e.g., file modifications), error conditions, and how to check progress, which are important for a mutation-like tool.

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

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

The description is a single sentence with 12 words, no fluff, and front-loads the action and return behavior. Every word earns its place.

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

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

While an output schema exists (so return format is covered), the description is thin on operational context. It doesn't mention that job_id can be used with sibling tools like get_job_status or stop_job, nor does it state prerequisites such as an existing case. Still, for a minimal start tool, it provides the essential 'what' and basic 'how'.

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

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

Schema description coverage is 0%, and the description does not explain the parameters. 'case_name' is self-explanatory from its name, but 'solver' is ambiguous and not described in any way. The optional nature of 'solver' is not mentioned in the description, leaving the agent to guess its meaning.

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 and resource: 'Start the OpenFOAM solver as a background job.' This clearly distinguishes it from sibling tools like generate_mesh or list_cases. It also adds the asynchronous behavior (background job) and immediate job_id return, making the tool's purpose unambiguous.

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

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

The description implies usage (when you want to run the solver) but provides no explicit guidance on when to use this tool versus alternatives, prerequisites (e.g., existing case, mesh), or exclusions. No mention of how job_id connects to monitoring tools like get_job_status.

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 fully disclose behavior. It reveals that force=true sends SIGKILL (implying a non-force stop is gentler), but it does not disclose whether the stop is reversible, what happens to data or state, whether special permissions are needed, or any side effects. This meets the minimum for a stop operation but leaves significant behavioral gaps.

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

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

The description is two short sentences with zero wasted words. It front-loads the primary action and follows with a critical parameter detail. Every word earns its place.

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

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

The tool is simple, but the description leaves out important operational context that could affect agent decisions, such as whether stopping is irreversible, whether force=true is recommended in certain scenarios, or whether the tool returns a status/error state (though an output schema exists). The description is sufficient for basic use but lacks depth for a robust agent.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the 'force' parameter's effect (sends SIGKILL), which clarifies the boolean's meaning beyond the schema. The 'job_id' parameter is self-explanatory and doesn't require elaboration. This adds value but does not fully document all parameter nuances (e.g., job_id format).

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 ('Stop') and a clear resource ('a running job'), unambiguously stating the tool's core function. It is distinct from all sibling tools, which focus on listing, creating, or managing cases/meshes/solvers, not on stopping jobs.

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 clearly implies when to use the tool (to stop a running job) and even hints at a conditional ('force=true'), but it does not explicitly state when to use this tool over alternatives or any exclusions (e.g., cannot stop jobs already finished). It provides context but lacks direct guidance on alternatives or 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?

No annotations are provided, so the description carries full burden. It does not disclose whether the operation is read-only, what 'spoken delivery' implies, potential side effects, or any limitations. The description is purely functional and lacks behavioral depth.

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

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

The description is a single sentence with no filler words. It front-loads the core action ('Summarize latest results') and succinctly lists the result categories. Every word earns its place, exemplifying strong conciseness.

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

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

With one parameter and 0% schema coverage, the description does not explain the purpose of case_name or any usage context. An output schema exists, so return format is covered, but the tool's purpose relative to case inputs and the meaning of 'spoken delivery' remain unclear, making the description inadequate for full contextual understanding.

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 description does not mention the parameter case_name, and schema coverage is 0%. It provides no explanation of how the parameter is used or what values it accepts beyond the schema's bare type definition. The description adds zero semantic value for the parameter.

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

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

The description states the tool summarizes latest results, specifying the content (times, parameters, residuals) and the intended use case (spoken delivery). This clearly identifies the tool's purpose and differentiates it from siblings like get_logs or compare_to_analytical, though it does not explicitly name alternatives.

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

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

No guidance is given on when to use this tool versus alternatives. The description does not mention prerequisites, typical scenarios, or exclusions. It simply states what the tool does, leaving the agent without context for selection.

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