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, but it only says 'Request safe cancellation.' It does not explain whether the cancellation is asynchronous, idempotent, reversible, or what 'safe' concretely means. The use of 'Request' hints at a non-forceful operation, but critical behavioral traits are left unstated.

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

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

The definition is very short and front-loaded, with no filler or redundancy. However, the terseness comes at the cost of crucial semantic context, making it borderline under-specified rather than appropriately concise.

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

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

Given the lack of annotations and the sparse description, the definition is incomplete for an agent trying to invoke the tool correctly. The output schema may cover return values, but the description does not clarify when cancellation is valid, what side effects occur, or how the request is processed by the Job Registry.

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

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

The schema has 0% description coverage, and the description does not mention the run_id parameter at all. While the single parameter is somewhat self-explanatory from its name, the description provides no additional meaning about accepted formats, constraints, or how the run_id relates to the Job Registry.

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 ('Request safe cancellation') and a resource context ('through the Job Registry'), which makes the tool's core purpose reasonably clear. It is distinct from its siblings, which focus on starting, planning, validating, or inspecting runs rather than cancelling them. However, it never explicitly mentions 'run' in the description, relying partly on the tool name and schema.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives, nor does it state conditions such as which run states are eligible for cancellation or whether this is preferred over other stop mechanisms. Usage is only weakly implied by the words 'safe cancellation' and the tool name.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It implies a read-only reporting action but does not explain the meaning of 'live', what the timeout controls, whether any external access occurs, or what kind of host information is collected.

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 free of fluff, which makes it concise. However, it is so minimal that it lacks meaningful structure or detail, and it leaves two parameters with unexplained 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?

The output schema covers return values, so that omission is acceptable, but the description still fails to explain the live/timeout behavior or offer any usage context. For a tool with no annotations and zero parameter documentation, this is incomplete.

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 mention either parameter. The meanings of 'live' and 'timeout_seconds' are left entirely to the agent to infer from names and defaults, providing no value beyond the input 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 uses a specific verb ('Report') and a clear resource ('installed host and PyAnsys capabilities'), so the tool's diagnostic purpose is immediately evident. It is also distinct from all sibling tools, which focus on model inspection, region resolution, validation, and run lifecycle management.

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

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

The description gives no guidance on when to use this tool versus alternatives, nor does it mention any prerequisites or recommended context, such as running it before a simulation. The intended use is weakly implied by 'Report capabilities' but never made explicit.

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 usefully reveals that the event history is 'append-only,' which is a meaningful behavioral trait. But it does not state whether the operation has side effects, requires a running run, or how the snapshot may differ from the event history. Some useful context is provided, but gaps remain.

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

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

The description is a single front-loaded sentence that directly states the core action and resources. It has no filler. It could earn a 5 by adding a brief note about run_id or usage, but as a concise statement it is 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?

Given the existence of an output schema, the return values may be covered elsewhere, but the description still lacks parameter semantics and usage guidance. With one required parameter and several closely related siblings, the description is not enough for an agent to confidently call this tool for the right purpose.

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 run_id at all. It mentions 'a job snapshot' but never links run_id to a job or run, leaving the only parameter's semantics entirely to the schema's bare type declaration. This is insufficient compensation for the 0% coverage.

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

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

The description uses the verb 'Return' with a specific resource: 'a job snapshot and its append-only event history.' This clearly communicates a read-oriented snapshot/history retrieval. However, it does not explicitly distinguish itself from sibling 'get_run_summary,' which likely overlaps conceptually, so it misses the last bit of 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?

The description gives no guidance on when to use this tool over alternatives like get_run_summary or list_run_artifacts. There are no exclusions, prerequisites, or context clues to help an agent decide among siblings. Its usage is only implied by the tool's name.

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

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

With no annotations, the description carries the full behavioral burden. It does disclose a meaningful output trait: results are bounded scalars with no field arrays. However, it says nothing about side effects, required permissions, or error behavior, so transparency is only partial.

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

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

The single sentence is compact and starts with the verb, which is good. But it is under-sized: it omits the run context entirely, so this is under-specification rather than efficient completeness.

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

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

Despite having an output schema and only one parameter, the description is incomplete in context. It never connects the result to the run_id input or to the run lifecycle, and the sibling tool set includes overlapping get/list operations that the description does not help disambiguate.

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 mention run_id at all. The only parameter is a required string named run_id, so the name is self-explanatory, but the description provides no additional semantics and does not compensate for the missing schema documentation.

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

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

The description names a verb ('return') and a result type ('bounded scalar results'), but never says these are results for a run or what a run summary contains. It is not a tautology, but it is too vague to fully differentiate from sibling get/status/list 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?

No when-to-use guidance is given. There is no mention of when to choose get_run_summary over get_run_status or list_run_artifacts, nor any caveat that this tool intentionally avoids arrays. The only hint is the phrase 'without any field arrays,' which is not enough to route an agent.

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

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

With no annotations, the description must carry behavioral disclosure, but it only hints that the output is a Geometry Graph. It does not state whether the operation is read-only, whether it creates artifacts, what prerequisites exist, or what happens for unsupported models.

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 brief and contains no filler, which is good, but the awkward phrase 'one confined supported' wastes clarity without adding useful information. It is concise but not cleanly 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?

The output schema covers the return value, but the description still lacks essential context about supported input formats, side effects, and how this tool relates to siblings like doctor or resolve_regions. It is not complete enough for an agent to confidently select and invoke it.

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 should compensate for explaining model_path, but it does not. It never mentions accepted file formats, path forms, or how the CAD model should be referenced, leaving the parameter's semantics mostly to inference.

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 ('Inspect') and resource ('CAD model') and names the expected output ('Geometry Graph'), which differentiates it from run- and region-focused siblings. However, the phrase 'one confined supported CAD model' is awkward and 'confined supported' is not defined, reducing clarity.

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

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

The description implies the tool is used when a CAD model needs to be converted into a Geometry Graph, providing a clear usage context. It does not explicitly state when not to use it or how it compares to alternatives like doctor or resolve_regions.

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

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

With no annotations, the description carries the behavioral burden. It discloses that the tool returns only metadata-like artifact information, not artifact contents, via 'paths, hashes, media types, and sizes only.' However, it does not mention access requirements, pagination, or behavior if the run_id is invalid.

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

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

The description is a single, front-loaded sentence with no filler. Every word earns its place, and the 'only' qualifier adds useful limitation information without redundancy.

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

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

The tool is simple, has one required parameter, and an output schema exists, so return-value documentation is unnecessary. Still, the missing run_id semantics and absent usage guidance leave minor but real gaps for an agent deciding whether and how to call it.

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

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

The schema has 0% description coverage, so the description must compensate. It never explains that run_id identifies the run whose artifacts should be listed; the only clue is the self-explanatory property name, which is not enough for a low-coverage 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?

Description uses a specific verb ('List') and resource ('artifacts'), and explicitly enumerates the returned attributes: paths, hashes, media types, and sizes. The trailing 'only' clearly scopes the tool away from sibling operational tools like doctor, start_run, or get_run_summary.

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

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

No guidance is given about when to use this tool versus related alternatives such as get_run_summary or inspect_model. The description states what it lists but not when an agent should choose it.

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

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

With no annotations, the description carries the full burden of explaining side effects. It discloses that the output is 'immutable' and 'reviewed', but does not say whether this creates persisted state, requires special permissions, can fail on unsupported recipes, or whether it executes the recipe.

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 redundant phrasing. It is appropriately terse, though the unexplained acronym prevents it from being maximally 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?

Even with an output schema present, the description omits key context: what CAE-IR is, how run_id affects behavior, and how this step relates to starting or validating a run. An agent would struggle to know prerequisites, side effects, or when this tool is the correct choice.

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 only indirectly implies that recipe_path is the recipe input. The run_id parameter is completely undocumented, including its optional/nullable nature and intended role.

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 ('Compile') and resource ('a supported recipe') with a concrete output ('immutable reviewed CAE-IR'), which distinguishes it from execution-oriented siblings like start_run and validate_run. However, 'CAE-IR' and 'reviewed' are undefined, so some clarity is lost to jargon.

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

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

No guidance is given on when to use this tool versus alternatives such as validate_run or start_run. There are no stated prerequisites, exclusions, or explicit context for whether planning/compilation must happen before execution.

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

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

No annotations are provided, so the description carries the full behavioral burden. The verb 'Resolve' implies a read/compute operation, but the description does not disclose side effects, prerequisites (e.g., recipe must exist or be valid), failure behavior when regions cannot be resolved, or 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?

The description is a single eight-word sentence with a front-loaded verb and zero wasted words. For a simple one-parameter tool this is appropriately sized, though it leans toward under-specification rather than rich concision.

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 only one parameter, no annotations, and an existing output schema, the burden on the description is low and return values need not be explained. However, the description still lacks usage guidance, behavioral disclosure, and a definition of 'semantic regions', leaving gaps that matter for an agent deciding to invoke the 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 description coverage is 0%, so the description must compensate for the bare 'recipe_path' string parameter. The description does add the essential semantic link — recipe_path is the Run Recipe whose regions are resolved — which gives the parameter meaning. Format details (absolute/relative path, supported recipe types) are still absent, but the core meaning is conveyed.

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 ('Resolve') and a specific resource ('semantic regions referenced by one Run Recipe'), which distinguishes it from the run-lifecycle siblings (validate_run, plan_run, start_run, etc.). However, 'semantic regions' is unexplained domain jargon, so an agent cannot fully know what is being resolved or what the operation produces.

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 siblings like plan_run, validate_run, or inspect_model. The phrase 'referenced by one Run Recipe' only hints at a scoping constraint, not a selection criterion or exclusion condition. An agent must guess when resolving regions is the appropriate step.

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 explaining behavior. It usefully discloses that the operation is asynchronous ('Enqueue') and that it returns a durable QUEUED snapshot rather than blocking for completion. However, it omits other important behavioral details such as idempotency, failure modes, permissions, or what happens to the run after queueing.

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 an active verb and no filler. 'Durable QUEUED snapshot' compactly conveys the core return contract without wasting words.

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

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

The description covers the core enqueue-and-return behavior, and the presence of an output schema helps with return-value expectations. However, the lack of parameter semantics and the absence of guidance around prerequisites or sibling workflow steps make it only minimally complete for an agent deciding how to invoke this 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%, and the description does not explain either run_id or recipe_path. recipe_path is somewhat inferable as the recipe to run, but run_id is opaque: the schema only shows it is optional with a null default, and the description adds no meaning about when or why to supply it.

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

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

The description states a specific verb and resource: it 'Enqueue[s] a run' and immediately returns its snapshot. This clearly distinguishes it from sibling lifecycle tools like validate_run, plan_run, cancel_run, and get_run_status, which are about checking, planning, canceling, or reading rather than 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 description clearly implies the tool is used to launch a run, but it gives no explicit when-to-use or when-not-to-use guidance relative to siblings. An agent must infer from sibling names that validate_run or plan_run might be prerequisites, and no alternatives 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?

No annotations are provided, so the description carries the full burden. It does not disclose whether validation is read-only, what happens on invalid recipes, whether external contracts are fetched, or any side effects. The scope 'all referenced contracts' is useful but does not cover behavioral traits.

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, front-loaded sentence with no filler. Every word contributes to defining the tool's scope.

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 one required string parameter and an output schema, the core operation is stated. However, important context is missing: usage order relative to plan_run/start_run, what 'referenced contracts' means, and what the validation result looks like. The lack of annotations makes this more noticeable.

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

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

The schema has 0% description coverage, so the description must compensate. It connects recipe_path to the Run Recipe being validated and mentions referenced contracts, giving some meaning. However, it does not specify path format, resolution behavior, or constraints beyond the schema's required flag.

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 ('Validate') and resource ('one Run Recipe and all referenced contracts'), making the tool's purpose immediately clear. It is distinct from siblings like plan_run and start_run, which imply execution rather than validation.

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

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

No explicit guidance is given about when to use validate_run versus alternatives such as plan_run, start_run, or doctor. The intended pipeline ordering is only implied by the tool name and sibling context, not stated.

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