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

The annotations already declare readOnlyHint=true and openWorldHint=true, so the description does not need to restate that this is a safe read operation. The description adds that the tool reports rate limits and usage counts, which is useful context. It does not disclose details like reset timing or units, but for a zero-parameter read-only tool this is acceptable.

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

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

The description is a single, front-loaded sentence that states exactly what the tool does. Every word earns its place, and there is no redundant or filler content. It is appropriately sized for the simplicity of the tool.

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

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

For a zero-parameter, read-only status tool, the description adequately conveys what the agent will get: rate limits and usage counts. There is no output schema, so the description carries the burden of describing return content, and it does so. It could mention units or reset period, but the current level is sufficient for correct invocation and expectation-setting.

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 schema description coverage is 100%, so there are no parameter semantics to clarify. Per the baseline for zero-parameter tools, the description does not need to compensate for any parameter documentation gaps. Nothing more is needed here.

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 ('Show') and names the exact resource: API rate limits and call usage. This clearly distinguishes it from the sibling tools, which are all about simulations, storage, or file operations. An agent can immediately tell what this tool does without needing to inspect anything else.

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 makes the usage context clear: call this tool when you need to know API rate limits or consumed quota. There are no competing alternatives among the siblings for this kind of information, so explicit when-not-to-use guidance is unnecessary. It provides clear context without 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 indicate destructiveHint=true and readOnlyHint=false, so the description's extra value lies in explaining irreversibility and the confirm-gating workflow. It adds meaningful behavioral context beyond the structured annotations, especially the requirement for a summary-then-confirm pattern.

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 compact and front-loaded. The first sentence states the core action and consequence, and the second provides the required workflow. No filler or redundant restatement of the tool name exists.

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 destructive tool with two simple parameters and no output schema, the description is sufficiently complete. It covers the action, irreversibility, confirmation flow, and user-consent requirement. An agent has everything it needs to invoke the tool correctly, even though the exact summary format is not described.

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 fully explains the confirm parameter by tying confirm=false to the summary step and confirm=true to actual deletion after user approval. However, the path parameter is only indirectly implied as 'a file or folder from storage' and lacks details like path format, root location, or whether it accepts directory paths, leaving a notable 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 ('Delete') and resource ('a file or folder from storage'), and clearly marks the operation as irreversible. This distinguishes it cleanly from sibling tools like list_storage, upload_folder, and download_results, which perform different actions on storage.

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 an explicit two-step usage protocol: call with confirm=false first to obtain a summary, show it to the user, and only call with confirm=true after explicit user agreement. This is concrete, actionable guidance that leaves no ambiguity about how to safely invoke the tool.

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

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

The description discloses useful behavioral details (local_dir created if missing, extract deletes archives after unpacking, files_to_get defaults to all archives). However, the annotation destructiveHint=false directly contradicts the description's statement that extract will 'delete them after' unpacking, so the agent receives conflicting safety signals.

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 text is front-loaded with the main purpose and then uses one compact line per parameter with no filler. Every sentence adds operational information the schema lacks.

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

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

For a four-parameter tool with no output schema, the description provides enough operational detail to invoke it correctly, including defaults and side effects. The only notable gap is the lack of success/return-value information and the unresolved contradiction with destructiveHint, which slightly reduces completeness.

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 compensates by explaining every parameter: folder is the storage folder, local_dir is created if missing, extract controls unpack/delete behavior, and files_to_get is an optional filter defaulting to all result archives. This goes well beyond the bare property names in the schema.

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

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

The opening sentence names a specific action ('Download result archives of a storage folder to a local directory') with a clear object and destination, so an agent can immediately identify the tool's role. The parameter lines further scope it to result archives and distinguish it from sibling tools like list_results or get_download_link.

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 clear usage context: it is for downloading result archives from a storage folder to local disk, with files_to_get as an optional filter and extract as a post-processing step. It does not explicitly contrast with get_download_link or list_results, but the stated workflow is enough to select it for bulk archive retrieval.

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

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

The annotations declare readOnlyHint=true, which matches the non-destructive nature of generating a download link. The description adds the key behavioral trait that the link is 'temporary', which is beyond the annotation. It does not mention any authentication requirements or rate limits, but the annotations cover the safety profile adequately, so a 3 is appropriate.

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 includes the essential information: what the tool does and an example of the parameter. It is front-loaded with the action and resource, and contains no unnecessary 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?

The tool is simple with one parameter, and the description covers the core purpose and an example. However, it does not clarify the distinction from 'get_upload_link' or 'download_results', which are relevant siblings. Given the simplicity and the lack of an output schema, the description is adequate but could benefit from explicit differentiation.

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 provides an example of the path format ('myCase/FDS.tar.gz'), which adds meaning beyond the raw 'path' string in the schema. However, with only one parameter and high simplicity, the schema and description together are sufficient. The description does not fully compensate for the 0% schema coverage, but the example helps.

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: obtaining a temporary download link for a storage file. It uses a specific verb ('Get') and a specific resource ('download link') with an example path, which distinguishes it from other tools like 'list_storage' or 'download_results'. However, it doesn't explicitly name a sibling tool to avoid confusion with the similar 'get_upload_link'.

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: to get a download link for a file in storage. However, it does not provide guidance on when to use this tool versus alternatives like 'download_results' or when not to use it. The presence of a 'path' parameter suggests it is for specific files, but no explicit exclusions or alternatives are given.

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

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

Annotations already indicate readOnlyHint=true and openWorldHint=truelint. The description adds valuable behavioral context beyond annotations by explaining that include_log appends log lines and diagnoses known cloudHPC errors with fixes, and that a simulation can be COMPLETED even if the solver failed. This helps agents understand non-obvious status 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 description is compact and front-loaded: the first sentence states the tool's purpose, and the second paragraph explains the one nuanced parameter with a concrete usage rule. Every sentence earns its place without redundant filler.

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

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

For a read-only status tool with two simple parametersley, the description covers the essential behavior and the edge case around successful completion versus solver failure. It does not describe the full return shape, but no output schema is provided and the status/details are implied sufficiently for an agent to call it correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It meaningfully explains include_log, describing the added log lines and diagnostic content, which goes beyond the schema's bare boolean flag. simulation_id is not elaborated, but its meaning is clear from its name and integer type.

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 'Get status and details of a simulation', which clearly identifies the verb and resource. It does not explicitly differentiate from siblings like wait_for_simulation or sync_simulation, but the direct phrasing makes the tool's core purpose understandable.

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 clear contextual guidance for the include_log parameter: 'Use it whenever a run ends, since a run can be COMPLETED even if the solver failed.' This is useful and specific, though it does not compare get_simulation against alternative sibling tools such as wait_for_simulation or list_simulations.

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 indicate readOnlyHint=false, openWorldHint=true, and destructiveHint=false. The description adds context about returning a signed URL and restricting uploads to certain archive formats, but it does not disclose behaviors like URL expiration, permissions, or whether the folder must already exist. This is acceptable given the annotations, but not exceptionally transparent.

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 paragraphs with no filler. The first sentence states the tool's purpose, and the second paragraph provides necessary compression and format details. Every sentence earns its place.

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

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

For a two-parameter tool with no output schema, the description covers the critical invocation details: what to compress, how to structure the archive, where to upload it, and allowed formats. It omits optional details like URL expiration or folder existence checks, but it is complete enough for a competent agent to call 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?

Schema description coverage is 0%, so the description must compensate. It does: 'storage folder with the case name' maps storage_folder to a case-named folder, and the accepted zip/tar.gz/7z/rar/xz formats clarify what filename should contain. This adds meaning beyond the bare property 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?

The description opens with a specific verb and resource: 'Get a signed URL to upload one file into a storage folder (remote clients).' It clearly distinguishes this from siblings like upload_folder and get_download_link by emphasizing the signed-URL and remote-client angle, so an agent can identify the tool's core purpose immediately.

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

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

The description provides concrete usage context: for a case folder, compress the folder contents without a wrapping folder, use an accepted archive format, and upload into a storage folder named after the case. It does not explicitly name alternatives or state when not to use the tool, but the instructions are clear enough for the main intended workflow.

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 readOnlyHint and openWorldHint annotations, the description discloses that the tool is local-only, reads specific solver file formats, and checks named pre-flight criteria. This gives the agent a concrete behavioral model of a side-effect-free local inspection operation.

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

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

The first sentence states the core purpose, and the following clauses add distinct details about supported formats, checks performed, and the no-API-calls constraint. Every sentence earns its place, and the actionable 'Fix error items before uploading' hint is useful without being verbose.

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 one parameter, clear annotations, and no output schema, the description covers what the tool does, what it reads, and how it fits into the pre-upload workflow. The only minor gap is that it does not describe the exact structure of the returned inspection results, but an agent still has enough to invoke and interpret 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?

The only parameter, folder, has no schema description, so the description must compensate. It adds meaning by stating that the parameter should refer to a 'local case folder' and enumerates the file formats and structures inspected. It does not specify path format or existence requirements, but for a single self-describing parameter this is adequate.

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 ('Inspect') and object ('a local case folder') and names two concrete goals: detecting the solver/model size and running pre-flight checks. It clearly distinguishes this local pre-upload inspection tool from sibling cloud operations like upload_folder or launch_simulation.

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 says this works on a local case folder, makes no API calls, and instructs the agent to fix 'error' items before uploading, which establishes a clear workflow context. It does not explicitly name alternative tools or list when not to use it, but the 'before uploading' and 'Makes no API calls' signals provide strong 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?

Beyond annotations, it discloses that the operation costs money, which is a critical real-world side effect. It also reveals the confirm workflow, the distinction between preemptible and non-preemptible instances, and the optional mesh reuse behavior. These traits are not derivable from annotations and materially affect an agent's invocation decision.

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 compact and front-loads the most important operational fact: 'Costs money.' Each parameter line earns its place by mapping to a schema property, and the confirm flow is stated in one clear directive. There is no filler 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?

This is a 7-parameter, financially consequential tool with no output schema, yet the description covers every parameter, the approval workflow, cost implications, and resource sourcing from sibling tools. It even tells the agent to show the returned summary to the user, covering the immediate post-invocation behavior. Nothing essential is missing for correct call selection and execution.

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 carries full responsibility for explaining parameters. It explicitly maps solver to list_solvers, cpu/ram to suggest_resources or list_machine_options, folder to the storage case, mesh_folder to an optional mesh, and regular_instance to a more expensive non-preemptible machine. This compensates completely for the bare schema.

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

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

The description opens with a specific verb and resource: 'Launch a simulation on a case folder already in storage.' It also distinguishes this from sibling tools like wait_for_simulation, stop_simulation, and list_simulations by emphasizing the launch action and cost. The phrase 'already in storage' clarifies the prerequisite state without ambiguity.

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

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

The description gives clear operational guidance: how to pick solver, cpu/ram, folder, mesh_folder, and regular_instance, and where to source those values from sibling tools. It also prescribes the two-call confirm flow with explicit user approval. It does not mention when not to use this tool, but the instructions are otherwise explicit and actionable.

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

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

The description aligns with the readOnlyHint annotation, confirming a read operation. It adds context about the specific information returned (vCPU counts, RAM/instance types), but does not disclose additional behavioral traits or limitations 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?

The description is a single, front-loaded sentence with no unnecessary words. Every word contributes to identifying what the tool does.

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 no-parameter, read-only list tool, this description is complete: it states exactly what information is returned, and the annotations confirm the operation is safe. An agent can invoke it correctly without any additional context.

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

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

The tool has zero parameters, so there are no parameter semantics to explain. The empty input schema fully represents the calling contract, and the baseline for a 0-parameter tool is a 4.

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

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

The description uses a specific verb ('List') and a precise resource ('vCPU counts and RAM/instance types that can be requested'). This clearly distinguishes the tool from sibling listing tools like list_solvers and list_storage, which cover different objects.

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

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

No guidance is given on when to call this tool versus alternatives. The phrase 'can be requested' implies it should be used before requesting resources, but this is left to inference rather than stated explicitly.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the description does not need to repeat that it is read-only. It adds context by specifying the file patterns (FDS.tar.gz, OPENFOAM-*.tar.gz), which helps the agent understand what is listed, but it does not disclose additional behaviors like output format or pagination.

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, focused sentence that front-loads the main action and includes useful examples. There is no unnecessary wording, making it highly concise and well-structured.

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 operation with one parameter and no output schema, the description is adequate but lacks details on the return format (e.g., whether it returns file paths, sizes, or links). Given the sibling tools for downloading, the agent might need more context, but the low complexity and read-only annotation keep it acceptable.

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

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

Schema description coverage is 0%, so the description must compensate. It clarifies that the 'folder' parameter refers to a 'case folder', adding meaning beyond the schema's bare 'folder' label. However, it does not specify the exact format (e.g., path or ID) or any constraints, leaving some ambiguity for a single required 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 clearly states the verb 'List' and the resource 'result archives of a case folder', with concrete examples (FDS.tar.gz, OPENFOAM-*.tar.gz). This distinguishes it from sibling tools like list_solvers and list_storage, making its 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 by naming the resource, but it does not explicitly state when to use this tool over alternatives or when not to use it. For example, it does not clarify how it differs from download_results or get_download_link, leaving the agent to infer based on 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?

Annotations already provide readOnlyHint=true and openWorldHint=true. The description adds useful behavioral context by specifying the ordering ('most recent first') and expanding the 'active' status to include pending/running/stopping, but it does not disclose output format, pagination, or limit behavior.

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

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

The description is short, front-loaded with the main purpose, and every sentence provides some information. The status line is slightly fragmentary but remains efficient and readable.

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

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

For a two-parameter read-only list tool, the description covers the essential filtering and ordering behavior. However, with no output schema, it does not describe the return shape or limit semantics, leaving some gaps in what an agent should expect.

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 'active' value as pending/running/stopping, which adds meaning beyond the raw enum, but the limit parameter is left undescribed and the status values largely repeat the schema's enum.

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 verb ('List'), resource ('simulations'), scope ('the user's'), and ordering ('most recent first'). It is distinguishable from siblings like get_simulation and stop_simulation by the list action, though it does not explicitly name any alternative tool.

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

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

There is no guidance on when to use this tool over siblings such as get_simulation or list_results. The status list describes filters, not decision criteria for tool selection, and no prerequisites or exclusions are mentioned.

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 establish readOnlyHint=true, and the description's 'List' is consistent with that. The description adds useful behavioral context: results are grouped by family and search is case-insensitive. It does not detail output format, pagination, or any potential filtering edge cases, but for a read-only listing tool the additional context is sufficient.

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

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

Two front-loaded sentences: the first states the tool's purpose, the second explains the optional parameter. No filler or redundant content; 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 read-only list tool with one optional parameter and no required inputs, the description covers purpose, grouping, and search behavior. Annotations cover the read-only safety profile, and no output schema is present, but an agent has enough information to select 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?

Schema coverage is 0%, but the description fully documents the single 'search' parameter, including that it is optional, case-insensitive, substring-based, and provides concrete examples ('openfoam', 'fds6.9'). This goes well beyond the bare string|null schema definition.

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

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

The description clearly states a specific action ('List') and a distinct resource ('solvers/scripts available on cloudHPC'), and adds the organizational detail ('grouped by family'). This distinguishes it from sibling list tools such as list_machine_options, list_storage, list_results, and list_simulations without ambiguity.

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

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

The description implies clear usage: call this when you need to discover available solvers/scripts on cloudHPC, optionally using the search substring. There are no direct sibling alternatives for this exact resource, so no exclusions are needed, but explicit 'use when' guidance is not stated.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true. The description adds the path-scoping convention but not additional behavioral context like listing depth, pagination, or the shape of the response.

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

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

Two short lines front-load the action then define the parameter. Every sentence adds information; no filler 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 one-parameter read-only tool this is nearly complete: action, storage scope, and path syntax are covered. It lacks explicit information about the returned listing's contents or format, but that is not required to 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?

Schema has 0% description coverage, merely 'Folder' with a default. The description compensates fully for the single parameter by defining the path, the root sentinel (''), and examples of nested paths.

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 action and resource: 'List files and folders in the user's cloudHPC storage.' This distinguishes it from sibling tools that operate on simulations, solvers, or results, though it does not explicitly contrast with list_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 implies the tool's use for browsing storage and documents how to target a folder, but it never states when to prefer this over adjacent tools such as list_results or download_results. No exclusion or alternative guidance is 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 readOnlyHint=true and openWorldHint=true, so the base safety profile is covered. The description adds valuable behavioral context: the link is short-lived and personal, and should only be given to the user. This goes beyond annotations and helps the agent understand the security implications.

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, front-loaded with the main purpose, and the second sentence adds crucial security context without bloat. 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 with one parameter and no output schema, the description covers the essential purpose and a key behavioral trait (short-lived link). It implies the simulation must be running and does not require prerequisites or error handling. The only minor gap is lack of explicit parameter guidance, but that is addressed in parameter_semantics. Overall, it is complete for an agent to call it correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It implies the parameter is a simulation_id by saying 'of a running simulation', but does not explicitly explain the parameter, its format, or constraints. For a single integer parameter, the implication is weak compensation; an agent would need to infer the ID's meaning from the tool name and description.

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

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

The description clearly states the action 'Get' and the resource 'browser remote-desktop (VNC) link of a running simulation'. It is specific and distinct from siblings like get_download_link or get_upload_link, which serve different purposes. The purpose is immediately 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 provides no explicit guidance on when to use this tool versus alternatives. It only mentions that the link is short-lived and personal, which is a handling instruction rather than usage context. An agent would have to infer that this is for viewing a running simulation, but no exclusions or alternative routing 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 signal destructiveness, and the description adds useful behavioral context: soft mode stops cleanly and saves results, while hard mode terminates immediately. The confirmation protocol is also disclosed, though the description could be more explicit about what hard mode may destroy or lose.

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 compact and front-loaded, with every sentence serving a distinct purpose: what the tool does, mode semantics, and the confirmation workflow. There is 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?

For a destructive tool without an output schema, the description covers the key invocation requirements: target simulation, mode choice, and confirmation behavior. It does not detail error cases or the full outcome of hard mode, but the provided guidance is sufficient for an agent 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 adds essential meaning for the mode and confirm parameters: soft vs hard behavior and the safe confirmation sequence. simulation_id is not elaborated, but its role as the target identifier is obvious from the schema and tool name.

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

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

The description opens with 'Stop a running simulation,' which is a specific verb+resource statement that clearly defines the tool's purpose. It also distinguishes this tool from siblings like launch_simulation and wait_for_simulation by focusing on termination.

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 indicates when to use the tool and provides a concrete two-step confirmation workflow: call with confirm=false, show the summary, then use confirm=true only after user agreement. It recommends soft mode as the default, but it does not explicitly name alternative tools or state exactly when hard mode is appropriate.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds the 'cloudHPC scalability rules' context but does not disclose output behavior, such as what the suggestion response contains or whether external data is queried.

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 front-loaded with a clear one-sentence purpose, followed by a compact parameter legend. Each line adds useful information, though the fds_* entry is terse to the point of ambiguity.

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 9 parameters, no output schema, and minimal annotations, the description covers most parameter semantics but is incomplete in important areas. It does not describe the return value shape, and the fds_meshes, fds_mpi_groups, and fds_total_cells parameters are not fully specified. The case_folder note also conflicts slightly with solver being a required schema parameter.

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 carries the full semantic burden. It does this well by explaining the domain-specific meaning of cells, nodes, elements, fds_*, case_folder, and prefer_speed, with solver examples. However, the fds_* parameters are grouped vaguely and not individually disambiguated.

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 opens with a specific verb and resource: 'Suggest vCPU and RAM type for a run'. This clearly differentiates the tool from siblings like list_machine_options or launch_simulation, since it is about recommendation rather than listing or launching.

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 intended use case, suggesting resources for a cloudHPC run, is implied by the first sentence and the parameter notes. However, there is no explicit discussion of when to prefer this tool over siblings such as list_machine_options, nor any stated exclusions or alternatives.

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

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

Annotations already mark this as mutating (readOnlyHint=false) but non-destructive. The description adds useful context by indicating the action is a request to a running simulation and involves partial results, but it does not clarify whether the upload is synchronous or fire-and-forget, or what side effects on storage occur.

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

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

One sentence with no wasted words. The action, target, and timing are all stated upfront in a compact, readable form.

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 low complexity—one required integer parameter, no output schema, and informative annotations—the description is sufficient for an agent to invoke it correctly. It could add minor details like return behavior or prerequisites, but nothing critical 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?

With 0% schema description coverage, the description compensates by implying that simulation_id must refer to a currently running simulation. This adds semantic constraint beyond the schema's type/required metadata, although it does not elaborate on ID format or error conditions.

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 ('Ask') with a clear resource ('a running simulation') and outcome ('upload partial results to storage now'). This distinguishes it from siblings like stop_simulation, wait_for_simulation, and user-driven upload 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 implies the appropriate context: a simulation is running and the agent wants partial results flushed to storage now. However, it does not explicitly state when not to use it, nor does it name any alternative sibling like wait_for_simulation or download_results.

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

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

The description discloses key behavioral details beyond annotations: it compresses the folder into upload.tar.gz, skips hidden files, and defaults storage_folder to the local folder name. Annotations already indicate a write (readOnlyHint=false) and non-destructive (destructiveHint=false), so the description adds context about the exact operation and return value.

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 three sentences with no fluff. The main action is front-loaded, and essential details (hidden files skipped, return value) are included concisely. Every sentence adds value.

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 complete for this tool. It explains the input, the process, the default behavior, and the return value (which is important since there is no output schema). It also ties the return value to launch_simulation, giving the agent full context for the next step.

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 fully compensates by explaining folder as the local case folder to compress and storage_folder as the target cloud storage folder with a default. It gives meaning to both parameters, which the bare schema 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 states a specific action (compress and upload) on a specific resource (local case folder) to a specific destination (cloudHPC storage). It distinguishes itself from siblings like get_upload_link and download_results by explaining the upload process and its role in preparing for launch_simulation.

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 as a preparatory step for launch_simulation by stating it returns the storage folder to use in that tool. It provides clear context but does not explicitly mention alternatives or when not to use it. Still, it is enough for an agent to understand when to invoke 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?

Annotations declare readOnlyHint=true and openWorldHint=true. The description aligns with readOnlyHint by indicating it only waits and does not mutate anything. It adds valuable context about polling behavior, rate limits, and the recommended approach for handling 'still running' responses. However, it doesn't specify the exact return values or what 'still running' means precisely, but with annotations covering safety, it's quite transparent.

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 appropriately sized, with a clear first sentence stating the purpose (front-loaded), followed by a brief but essential note on polling and rate limits. Every sentence adds value with no redundancy. It is concise and well-structured for quick consumption by an agent.

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 (3 parameters, no output schema, no nested objects) and annotations covering safety, the description is quite complete. It covers the waiting condition, the timeout, and the polling strategy. The only minor gap is that it doesn't explicitly state what happens on timeout (max_minutes reached), but that's implied. Realistically, an agent has enough information to call it correctly.

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

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

Schema description coverage is 0%, so the description must explain parameters. It mentions 'max_minutes' and 'poll_seconds', and provides a minimum bound for poll_seconds (min 60) to respect rate limits. It implies that max_minutes is the overall wait timeout. This adds meaning beyond the basic schema definitions (type, default), such as the rate limit constraint, which is crucial for correct usage. It could have explicitly defined each parameter, but the coverage is reasonable.

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: wait until a simulation is no longer pending/running or until max_minutes is reached. It uses a specific verb ('wait') and identifies the resource (simulation) and the condition. This effectively distinguishes it from siblings like 'launch_simulation', 'get_simulation', or 'stop_simulation', which involve different actions.

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 explicitly provides usage guidance: it explains the polling behavior, recommends a minimum poll interval of 60 seconds to respect API rate limits, and advises that if the tool returns 'still running', the agent should call it again later rather than looping quickly. This is clear, actionable guidance on when and how to use the tool, though it doesn't explicitly compare to alternatives, it's sufficient for a polling/waiting tool.

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