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

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses the whole-batch-when-empty conditional, but it does not state whether cancellation is irreversible, what happens to running jobs, or any permission requirements.

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

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

A single, front-loaded sentence with an active verb and no filler. Every word contributes meaning, and the important edge case is included without extra noise.

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

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

The tool is low-complexity and an output schema exists, so return-value documentation is not needed. However, with no annotations, the lack of cancellation semantics (reversibility, effects, prerequisites) leaves the definition only minimally complete for safe invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It does map 'selected case IDs' to case_ids and the empty case to whole-batch cancellation, but it never mentions the required batch_directory parameter or the maxItems constraint.

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 ('Cancel') with a clear scope: selected case IDs or the entire batch when the ID list is empty. This distinguishes it sharply from sibling tools like batch_submit, batch_status, and batch_resume.

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

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

Usage is implied rather than explicit: the description makes it clear this is the cancellation operation, but it does not say when to prefer it over alternatives or when cancellation is inappropriate (e.g., already-completed batches).

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 states 'without solving,' which is a meaningful behavioral trait (no computation), but it does not mention whether the operation is non-destructive, requires prior batch submission, or has any side effects. The description is minimal but not misleading.

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, ten words, front-loaded with the action and key constraint. No fluff; every word contributes to the purpose.

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

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

Despite being a simple tool with one parameter and an output schema, the description omits critical details: what 'batch_directory' should contain, how the format (CSV vs JSON) is selected, and prerequisites (e.g., must a batch snapshot already exist?). The agent cannot reliably invoke the tool correctly without further clarification.

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

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

Schema coverage is 0% and the description does not explain what 'batch_directory' refers to, its expected format, or how it relates to the saved snapshot. For a single required parameter, the description adds no semantic value beyond the schema, which is insufficient.

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 ('Export') with a clear resource ('saved batch snapshot') and output format ('CSV/JSON'), plus a distinguishing condition ('without solving'). This clearly differentiates it from siblings like batch_submit, batch_status, and batch_cancel.

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

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

It implies usage for exporting a saved batch, but does not explicitly state when to use it over alternatives like read_results or query. The phrase 'without solving' hints at a read-only operation but gives no conditions or exclusions, leaving the agent to infer the appropriate context.

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

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

With no annotations, the description carries the transparency burden. It discloses the key non-obvious behavior: only non-successful cases are retried, successful cases are verified/reused, and no successful cases are replayed. It does not discuss side effects or idempotency, but the core retry semantics are explicit.

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

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

Two short sentences with the action front-loaded and no filler. The verification checklist is compact, and the explicit no-replay constraint 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?

Given that an output schema exists and there is only one required request object, the description plus schema is mostly sufficient. It clearly states what gets retried and the verification preconditions; the main missing piece is guidance on when to use batch_resume instead of sibling batch tools.

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

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

The prose never mentions batch_directory or case_ids, and schema description coverage is 0% according to the context signals, so the description must compensate. Although the nested schema note about empty case_ids is useful, the tool description itself adds no parameter-level detail for invoking the tool correctly.

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 action and resource: 'Explicitly retry non-successful cases.' It further distinguishes itself by stating 'Never replays successful cases,' which separates it from a general batch run/status tool and from siblings like batch_submit or batch_cancel.

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

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

It gives a clear precondition: retry only after verifying the model, package, native binaries, specification, and successful artifacts. It also sets an exclusion (never replay successes), but it does not name alternative sibling tools or describe situations that would favor batch_submit/preflight instead.

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

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

With no annotations, the description carries the full burden. It only indicates a read operation and that progress persists across restarts. It does not disclose pagination behavior, required inputs, or any other caveats, leaving the agent with minimal behavioral insight.

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 that front-loads the verb and resource, with no wasted words. It is appropriately sized and easy to parse.

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

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

Given no annotations and a minimal schema, the description is too terse. It does not explain what a batch directory is, how it relates to sibling tools, or what 'progress' includes. An agent cannot confidently invoke this tool correctly from the description alone.

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

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

Schema description coverage is 0%, so the description must compensate. The word 'paginated' hints at limit/offset, but it does not explain their roles or that batch_directory is required. No parameter-level meaning is added beyond what the schema titles imply.

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

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

The description uses a specific verb 'Read' and a clear resource 'batch progress', with qualifiers 'paginated' and 'including after a restart' that add scope. This distinguishes it from sibling batch operations like submit, cancel, or export, and from read_results which likely returns final results rather than progress.

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 read_results or batch_resume. It simply states what it does, with no mention of typical contexts, 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 full disclosure responsibility. It reveals asynchronous behavior ('returns a durable batch directory immediately'), source preservation, no retry, and per-case private copies—non-obvious traits beyond what the schema shows. It does not mention failure_policy behavior, but the most important behavioral caveats are present.

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

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

Three sentences with no waste. The first sentence front-loads the action and constraints; the second routes to sibling tools; the third adds behavioral caveats. 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 complex submission tool, the description covers the essential operational facts: immediate durable directory, downstream workflow, source preservation, no retry, and isolation semantics. An output schema exists, so return values need not be described. The failure_policy default is in the schemaholistic; the description 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 description coverage is 0%, so the description must compensate. It maps well to some parameters: 'independent steady cases' → cases, 'CPU and parallel-job limits' → cpu_budget/max_parallel_jobs, and 'edit parameters on a private copy' → parameter_edits. However, geometry_file, output_dir, and failure_policy are not mentioned, leaving notable gaps that the schema (without top-level descriptions) does not fill.

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

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

States a specific verb ('Submit'), a clear resource ('independent steady cases'), and key constraints ('CPU and parallel-job limits'). The phrase 'durable batch directory' and mention of batch_status/batch_cancel distinguish it from sibling batch_* tools; the batch focus clearly separates it from run_vspaero.

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?

Tells the agent exactly what to do after submission: use batch_status, batch_cancel, batch_resume, and batch_export. It also states 'no automatic retry', which implies the agent must handle retries. It does not explicitly contrast with run_vspaero for single cases, but the batch framing makes the intended use clear.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. 'Create' implies mutation, but it does not describe side effects, required permissions, output behavior, or reversibility. The agent gets no warning about potential impacts.

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

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

The description is extremely short, which is good for conciseness, but it is under-specified and lacks structure. It does not front-load key information or earn its place with substantive content. It is more an omission than effective brevity.

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

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

The tool has an output schema and a nested request object with multiple properties, but the description provides no context. An agent cannot infer required parameters, how to structure the request, or what the output will be. It is inadequate 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?

Schema description coverage is 0%, so the description must compensate by explaining parameters, but it mentions none. The schema includes fields like template, case_name, output_dir, and set_commands, yet the description provides no meaning for them, leaving the agent without guidance.

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

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

The description states a clear verb 'Create' and resource 'model', but it is vague about what 'template or custom' means. It does not specify the model context (e.g., OpenVSP geometry) or distinguish itself from sibling tools like modify or inspect. The phrase 'template or custom' hints at options but lacks clarity on their meaning.

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

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

There is no guidance on when to use this tool versus alternatives. It does not mention that it creates a new model while modify edits an existing one, or any prerequisites like needing an existing project. The description gives no context for selection.

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

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

No annotations are provided, so the description carries the full burden of behavior disclosure. It implies a read-only status/version check but never explicitly states side effects, freshness guarantees, or what 'readiness' means. This is minimal disclosure, though not misleading.

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

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

The description is very short and front-loaded, with no filler. The phrase 'Fresh executable/API readiness and versions' is compact, though the word 'Fresh' is slightly vague and the fragment lacks a verb.

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

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

With zero parameters and an output schema present, the description does not need to enumerate return values. However, it is still somewhat cryptic and does not clarify whether this is a prerequisite check, a lightweight call, or how the version/readiness information should be interpreted.

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 100% schema description coverage, so there is no parameter meaning left to explain. The baseline of 4 applies because no parameters exist.

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 communicates that this tool reports executable/API readiness and version information, which is clearly distinct from the action-oriented sibling tools like batch_submit or create_model. It lacks an explicit verb like 'check' or 'get', but the meaning is still inferable from 'readiness and versions'.

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 explicit guidance on when to call this tool versus alternatives, nor does it mention whether it should be called before other operations. The intended use is only implied by the name and the word 'readiness'.

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 of behavioral disclosure. It clearly states the tool reads metadata and does not require OpenVSP, which implies a non-mutating, lightweight operation. However, it does not disclose what the output contains, whether it validates the file, or what happens with malformed or missing files. For a read-only inspection tool, the description is adequate but thin.

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

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

The description is a single, front-loaded sentence with no filler. Every word earns its place: 'Read' states the action, 'XML geometry metadata' states the resource, and 'without OpenVSP' states the key differentiator. It is appropriately sized for a simple one-parameter tool.

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

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

The tool has one required parameter, an output schema, and no annotations. The description is enough to understand the basic operation, but it does not explain what the returned metadata looks like, whether the output schema fully describes the return value, or how this inspection relates to the other openvsp tools. For a simple read tool, this is acceptable but not complete.

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

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

Schema description coverage is 0%, so the description must compensate. The description mentions 'XML geometry metadata' and the schema names the parameter 'geometry_file' with a description 'Path to the .vsp3 file', so the parameter's purpose is inferable. The tool description adds the context that the file is XML and that OpenVSP is not needed, but it does not explain the expected format, extension, or how the path is resolved. Baseline 3 is appropriate because the schema already documents the parameter, and the description adds only marginal context.

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 ('Read') and resource ('XML geometry metadata') and adds a meaningful qualifier ('without OpenVSP'), which distinguishes it from tools that require or launch OpenVSP. It does not explicitly name a sibling alternative, but the qualifier plus the tool name 'inspect' make the purpose reasonably clear.

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

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

The description implies usage: use this tool to read geometry metadata without needing OpenVSP. It does not explicitly state when to prefer it over siblings like openvsp.preview, openvsp.query, or openvsp.read_results, nor does it mention any exclusions or prerequisites. The 'without OpenVSP' phrase gives some context but not enough to fully route an agent among the many sibling 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?

With no annotations, the description carries the full burden of behavioral disclosure. It mentions 'Validate edits, then replace the source model,' which implies a destructive overwrite of the source model, but it does not state whether the original file is backed up, whether validation failures prevent replacement, or what happens to existing data. The word 'replace' hints at destructive behavior but lacks detail.

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

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

The description is extremely short and front-loaded: 'Validate edits, then replace the source model.' It is concise and to the point, but it omits necessary context. It earns a 4 for conciseness but not a 5 because it is too terse to be fully useful.

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 complexity (nested OpenVSPRequest with many fields, parameter edits, set commands, analysis settings) and the absence of annotations and output schema details, the description is incomplete. It does not explain the validation process, the meaning of 'replace the source model,' or how this tool relates to the broader workflow. An agent would struggle to use it correctly without additional information.

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 single 'request' parameter or its nested fields. The schema itself is rich, but the description adds no meaning about how to construct the request, what 'edits' means in terms of parameter_edits or set_commands, or how validation works. The description fails to compensate for the lack of 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 'Validate edits, then replace the source model' states a clear action (validate then replace) and resource (source model), but it does not specify what kind of edits or what model, and it does not distinguish itself from siblings like openvsp.set_parameters or openvsp.create_model. It is more specific than a tautology but leaves ambiguity about the exact operation.

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

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

The description gives no guidance on when to use this tool versus alternatives. It does not mention that this tool is for modifying an existing model, nor does it contrast with openvsp.set_parameters or openvsp.create_model. An agent would have to infer usage from the name and schema.

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. It only states that solving is not performed; it does not say whether the tool mutates the geometry file, executes set_commands or parameter_edits, or what happens when a check fails.

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

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

The description is a single, front-loaded sentence with no filler or redundancy. It is easy to parse, though the brevity comes at the cost of useful detail that other dimensions penalize.

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

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

Given the complex shared request schema and the absence of annotations, this description is incomplete: it omits the required geometry_file, the role of set_commands/parameter_edits, the meaning of 'geometry sets', and the operational context of a preflight check. An output schema exists, so return-value details are less critical, but invocation context is still under-specified.

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

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

Schema description coverage is 0% and the description contributes no parameter-level meaning. The single required 'request' parameter is an opaque wrapper around a large nested schema, and the description neither explains its fields nor connects 'geometry sets' to the geometry_file input.

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

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

The description names the operation ('check') and the resource ('loaded geometry sets'), and 'without solving' distinguishes it from solver tools like run_vspaero. However, it doesn't explain what a preflight check actually validates or differentiate it clearly from other non-solving siblings like inspect, preview, or query.

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?

'Without solving' implies the tool is meant for validation before or instead of running VSPAERO, but no explicit when-to-use guidance, prerequisites, or alternative tools are named. The intended usage context is only inferred from the phrasing and the sibling tool names.

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

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

With no annotations, the description must carry the full burden of behavioral disclosure. The phrase 'private model copy' hints that the original is not modified, but it does not explain side effects, permissions, output delivery, or error behavior. This is minimal information for a tool with such a rich request schema.

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

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

The description is extremely concise (one sentence), which is efficient, but it is under-specified. It is not appropriately sized for the tool's complexity; it omits essential context. Front-loading is fine, but the content is insufficient.

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 complexity (many parameters, nested objects, an output schema) and no annotations, the description is far from complete. It does not explain what the output looks like, how results are returned, or any operational details an agent would need to invoke it correctly.

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

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

The description adds no meaning about parameters. The single 'request' object is not explained; key fields like geometry_file, output_dir, or set_commands are not mentioned. Schema description coverage is 0%, so the description must compensate but fails to do so.

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 (Export) and the resource (SVG/STL from a private model copy). It implies a non-destructive operation and differentiates from tools like run_vspaero or create_model. However, it doesn't explicitly contrast with siblings like batch_export, so a small deduction for missing explicit differentiation.

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, when not to use, or how it relates to other export or preview tools. An agent receives no help in choosing this tool over others.

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 disclosure burden; it explicitly declares read-only behavior, pagination, and a model-dependent default caveat. It does not discuss errors or rate limits, but those are secondary for a read-only query and the output schema covers return shape.

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

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

Three short sentences front-load the main purpose and then add safety/pagination/context notes. There is no filler or repetition of schema content.

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

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

The output schema covers return values, but the description remains thin for a multi-field request: it doesn't specify which kind should accompany other fields, what 'native capabilities' means in practice, or how to choose between query and sibling inspection tools. It is adequate for a simple query but leaves real gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning by mapping the kind values (capabilities, analysis, parameters) to the query categories and by noting pagination, but it doesn't explain fields like geom_id, parm_ids, geometry_file, or timeout_seconds beyond what their names imply.

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

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

The description names a specific action (Query) and distinct resources — native capabilities, analysis input types/defaults, and geometry parameters — so an agent knows the tool's scope. It doesn't explicitly differentiate from sibling tools like openvsp.inspect, but the substance is unambiguous.

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

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

The read-only marker and the three query categories imply when to use this tool, and the note about analysis defaults depending on the supplied model gives context. However, it never names alternatives or states when not to use it (e.g., vs openvsp.inspect or read_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?

No annotations are provided, so the description carries the full burden. It discloses that the tool does not run OpenVSP, indicating a safe, read-only nature. However, it does not mention other behavioral aspects such as error handling, file access requirements, or the structure of returned data. The disclosure is minimal but not misleading.

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

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

The description is a single, front-loaded sentence with no filler. It efficiently conveys the primary purpose and the key constraint (no OpenVSP run), making it easy to scan and understand.

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

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

The tool has a nested parameter schema and no annotation coverage, yet the description offers almost no context about what 'manifest_file' refers to, what output to expect (despite an output schema existing), or any prerequisites. For an agent to call this correctly, it would need to infer heavily from the schema, making the description inadequate for the tool's complexity.

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 description coverage is 0%, and the description does not explain the parameters at all. It mentions 'coefficients' and 'log tails', which loosely map to coefficient_names and log_tail_lines, but there is no explicit link. The nested 'request' object and its required manifest_file are left entirely unexplained, so the description fails to add meaning beyond the raw schema.

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

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

The description clearly states the action (read), the resources (saved coefficients, settings, log tails), and the key condition (without running OpenVSP). It effectively distinguishes from sibling tools that run or submit jobs, such as run_vspaero or batch_submit, by emphasizing it is a read-only operation.

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

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

The description implies usage for reading saved results without running OpenVSP, but it does not explicitly name alternatives or provide criteria for when to use this tool versus others like query or batch_status. The guidance is implied rather than explicit, leaving some room for inference.

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

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

With no annotations, the description carries the behavioral disclosure burden. It does disclose that the source geometry is preserved and that actual solver inputs/results are verified, which is useful. However, it does not mention that this launches an external solver, may be compute/time intensive, or what side effects occur beyond source preservation.

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 short, front-loaded, and free of padding. The final sentence fragments ('Source preserved.' and 'fixed_wake selects...') are terse but acceptable; slight ambiguity in 'verify actual solver inputs and results' prevents a perfect 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?

For a tool with a complex nested request schema and no annotations, this description is under-specified. It omits guidance on how set_commands/parameter_edits interact, when run_vspaero should be set false, compute/time expectations, and how this tool relates to read_results or preflight. The presence of an output schema reduces the need to describe return values, but the remaining operational gaps are material.

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

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

Schema description coverage is effectively 0%, so the description must compensate, but it only explains one parameter: fixed_wake. The rest of the large nested request surface is left to parameter names and defaults. The 'steady subsonic condition' phrase weakly hints at Mach < 1, but most parameters get no added semantic context.

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 ('Solve'), a precise scope ('one steady subsonic condition'), and a distinguishing trait from sibling tools such as sweep or batch_submit. Even the tool name is less clear than this description, which specifies exactly what run_vspaero is for.

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 single-condition use but does not explicitly say when to choose this over openvsp.sweep, openvsp.batch_submit, or openvsp.preflight. It gives no exclusions, alternatives, or conditions that would route an agent to a more appropriate sibling.

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 transparency burden. It discloses a mutating side effect ('replace the source'), validation behavior ('verify limits'), and confirmation behavior ('readback'). It does not mention failure handling or output_dir effects, but the core safety-relevant behavior is described.

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 sentences, front-loaded with the action, followed by the key behavioral detail and the prerequisite. Every sentence contributes core information, with no filler.

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

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

The description covers the operation, validation, readback, side effect, and prerequisite, and an output schema exists so return-value documentation is not required. The main gap is lack of guidance on output_dir and timeout semantics, but schema titles and constraints mitigate this for a moderately complex tool.

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

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

Schema coverage is 0%, so the description must add parameter meaning beyond titles. It helps with parm_id ('Obtain IDs with openvsp.query') and value/source ('parameter ID/value edits', 'replace the source'), but does not explain the request wrapper, output_dir, timeout_seconds, or the edits array constraints. This leaves several parameters to be inferred entirely from schema titles.

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

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

The description names a specific verb ('Apply') and resource ('parameter ID/value edits'), and includes the intended atomized workflow ('in one load/update... then replace the source'). It also distinguishes itself from the query sibling by pointing to openvsp.query for ID retrieval, so an agent can tell which tool does which.

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 establishes the context for use (apply parameter edits) and gives one explicit prerequisite ('Obtain IDs with openvsp.query'). It does not spell out when not to use it or name alternative editing/sweep tools, but the intended invocation path is clear.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals that the sweep is sequential and limited to 1–25 conditions, but it does not mention side effects, blocking behavior, execution privileges, error semantics, or how results are returned. For a tool that likely runs server-side computations, this is a significant gap.

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

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

The text is very short, but this is under-specification rather than effective conciseness. It reads like a caption or title rather than a functional description secret, and it offers no structured details about inputs, execution, or expected behavior.

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

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

Given the complex nested request schema and lack of annotations, the description is insufficient for an agent to construct a valid call or anticipate execution behavior. The output schema may cover return values, but the core semantics of running the sweep are left largely unexplained.

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 request object or its key fields such as geometry_file, conditions, set_commands, or timeout_seconds. It only restates the 1–25 condition range already encoded in the schema via minItems and maxItems, plus the sequential execution ordering.

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 communicates that this is a 1–25 condition sequential sweep, which adds some scope. However, it is a noun phrase rather than a clear verb+resource statement—it never explicitly says the tool executes or runs a sweep, and it does not distinguish itself from sibling tools like run_vspaero or batch_submit.

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

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

There is no guidance on when to use this tool versus alternatives such as run_vspaero or batch_submit. No prerequisites, exclusions, or selection criteria are provided, leaving the agent to infer usage from the name and minimal description.

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