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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It only says 'Analyze', which implies a read-only operation, but it does not state whether the file must already exist, what the tool returns, whether any state changes occur, or what side effects might result.

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 with no filler, and the key action 'Analyze' appears first. It earns its place, though it is perhaps too terse to fully inform 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?

With no annotations, no output schema, and two parameters, the description leaves several important gaps: return value shape, parameter semantics, and conditions under which the tool is appropriate. An agent could guess the basic intent but would not know how to confidently invoke it or interpret results.

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 adds little about the parameters. It implies that the gcode parameter references a generated file under U1_OUTPUT_DIR, but it does not explain the expected format of that value or the meaning and effect of requested_material.

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 identifies a specific action ('Analyze') applied to a specific resource ('a generated G-code file') with a location qualifier ('under U1_OUTPUT_DIR'), making the core purpose understandable. It does not, however, specify what kind of analysis is performed or how it differs from sibling tools like compare_slices or smoke_slice.

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

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

There is no explicit guidance on when to use this tool versus alternatives, no exclusions, and no mention of prerequisites such as having already run u1_slice. The word 'generated' implies it should be used after slicing, but that is left to inference.

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

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

No annotations are provided, so the description must carry the behavioral disclosure burden. It says 'slice and compare' but does not reveal whether this runs the slicer, is computationally expensive, has side effects, or returns aggregated results versus individual slices. For a comparison tool with no annotations, this is a significant transparency 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 description is a single short sentence with no filler, and the core action is front-loaded. It is concise, though arguably too terse for a tool with this many parameters; the conciseness itself is not the problem, but the missing explanatory content is penalized in other dimensions.

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 7 parameters, no output schema, and no annotations, this tool demands a richer description to be safely invocable. The one-line description does not state how to structure orientation variants, what outputs are produced, whether runs/database entries are created, or what errors to expect. It is under-specified 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?

Schema description coverage is 0%, and the description names none of the seven parameters. It does not explain what 'controlled orientation variants' means structurally, how the 'orientations' array should be formatted, what 'overrides' contains, or what the key required inputs mean beyond their names. The description completely fails to compensate for the schema's lack of 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 states a specific verb and resource: 'Slice and compare controlled orientation variants.' It clearly conveys the core operation of slicing multiple orientation variants and comparing them, and it is distinguishable from plain slicing or inspection tools. However, it does not explicitly differentiate this tool from closely related siblings like u1_compare_transformed_orientations.

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

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

The phrase 'controlled orientation variants' implies a comparison/experimentation use case, but the description gives no explicit guidance on when to choose this tool over alternatives such as u1_slice, u1_compare_slices, or u1_compare_transformed_orientations. There are no when-to-use or when-not-to-use instructions.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. 'Compare' implies a read-only operation, but the description does not state that no changes are made, what output is produced, or how results are presented. This is a meaningful transparency 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 description is a single focused sentence with no filler or repetition, which is concise. However, given the tool's parameter count and lack of other documentation, the brevity borders on under-specification rather than efficient clarity.

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

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

With no output schema, no annotations, and no parameter descriptions in the schema, the description is the only source of context and it covers only the core operation. It omits required inputs, optional behavior, return expectations, and guidance for a 6-parameter tool, so it is not complete enough for reliable 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 for the six parameters. It adds some meaning by identifying process, filament, and recipe override sets, but it leaves the required 'model' parameter and optional 'nozzle' and 'verbose' parameters completely unexplained.

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 identifies a specific action ('compare'), a distinct resource ('built-in recipe override sets'), and a key constraint ('using the same process/filament'). It conveys what the tool does, though it does not explicitly distinguish it from sibling comparison tools such as u1_diff_profiles or u1_compare_slices.

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

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

The phrase 'using the same process/filament' implies the intended scenario: comparing override sets while holding process and filament fixed. However, the description gives no explicit guidance on when to choose this tool over alternative comparison or profile tools, nor does it state any exclusions or prerequisites.

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

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

No annotations are provided, so the description must carry the full behavioral burden. It indicates the tool slices and compares, but does not disclose whether it performs multiple expensive slice operations, what side effects exist, what the output looks like, or any constraints such as model/filament compatibility.

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 and front-loaded with the core action, and there is no filler text. However, for a tool with 5 parameters, a nested unstructured 'variants' array, and no output schema, this is under-specification rather than appropriate conciseness.

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

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

The description is far too thin for the tool's complexity. With no annotations, no output schema, 0% parameter coverage, and a loosely-defined 'variants' array accepting additional properties, an agent cannot reliably determine how to construct inputs or interpret results. Sibling comparison tools are not differentiated.

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 5 parameters, but it only vaguely references 'process/override variants.' It does not explain what each variant object should contain, how 'verbose' behaves, or what 'nozzle' defaults and constraints are beyond the schema's default value.

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

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

The description states a specific verb-resource pair: 'Slice and compare multiple process/override variants.' This distinguishes it from single-slice tools like u1_slice, though it does not clarify exactly how it differs from comparison tools like u1_compare_recipes or u1_diff_profiles.

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. The phrase 'compare multiple... variants' implies a multi-variant comparison use case, but no explicit when/when-not conditions or sibling alternatives are provided.

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 reveals that STL copies are transformed locally and that rotation flags are not used, but it does not disclose side effects, file outputs, failure modes, or whether the operation is safe or destructive.

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 short sentence, so it avoids verbosity, but it is under-specified rather than usefully concise. It front-loads an implementation detail instead of a clear purpose, and it omits essential context for a tool with seven parameters.

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 tool has seven parameters, no annotations, no output schema, and zero parameter coverage, yet the description explains almost nothing. Missing return behavior, parameter semantics, prerequisites, and usage context make the description inadequate for correct invocation.

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

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

Schema description coverage is 0% and the description provides no parameter meaning. The seven parameters, including required model, process, and filament, remain entirely unexplained, so an agent cannot infer correct values from the 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 names actions ('Transform STL copies locally, then slice') but never states what the tool compares or returns, despite the 'compare_transformed_orientations' name. It reads as an implementation detail rather than a purpose statement, and it does not distinguish this tool from siblings like u1_compare_orientations or u1_slice.

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 the sibling tools, prerequisites, or any selection criteria, so an agent cannot determine when this tool 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?

No annotations are provided, so the description must carry the behavioral burden. It discloses the confirmation guard, which is meaningful for a destructive operation, but it does not explicitly state irreversibility or what happens to associated artifacts.

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 entire description is one short, front-loaded sentence with no filler. It conveys the action and the critical safety requirement efficiently.

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

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

For a simple two-parameter destructive tool, the description is nearly complete: it identifies what is deleted and the confirmation requirement. It lacks explicit irreversibility or return-value info, but neither is essential for an agent to invoke this correctly.

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

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

Schema coverage is 0%, so the description must compensate. It clarifies that confirm must be true for deletion to proceed, but run_id is left to be inferred from the phrase 'run directory'. This is partially helpful but not a full parameter explanation.

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'), a precise resource ('one generated run directory'), and a unique action. It clearly distinguishes itself from the many read/analysis siblings such as u1_get_run and u1_list_runs.

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 a clear precondition: confirm=true is required. It does not name alternatives, but no other sibling performs deletion, so the usage context is sufficiently 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, yet it only says it returns diagnostics. It does not explicitly confirm that the tool is read-only, that it does not modify the model, or what inputs it requires beyond 'model'.

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 sentence is short, front-loaded with an active verb, and contains no structural waste. The word 'practical' adds little, but overall the description is 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?

For a single-parameter tool with no annotations, no output schema, and many sibling diagnostics, this description is too thin. It omits the input format, the nature of the diagnostics, and any guidance on choosing between this tool and related pre-slice diagnostic tools.

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

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

Schema description coverage is 0% and the description does not compensate: it never explains what 'model' should be (path, model id, name) or where to obtain it. The phrase 'model diagnostics' merely implies the parameter refers to the model being diagnosed.

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+resource combination ('Return ... diagnostics and suggestions') and scopes the work to the pre-slice phase, distinguishing it from later-stage operations like u1_slice. It does not, however, clarify exactly how it differs from nearby diagnostics such as u1_mesh_printability or u1_orientation_preflight.

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?

'Pre-slice' provides a clear temporal context: this is the tool to consult before slicing. It does not explicitly name alternatives or state when not to use it, so it stops short of full routing guidance.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. 'Diff' implies a read-only comparison, but the description does not explicitly state that it is non-destructive, what output it produces, how errors are handled, or whether any state changes occur. This is a minimal disclosure for a tool with zero annotation support.

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

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

The description is one short sentence with no filler and opens with the primary verb 'Diff.' It is appropriately compact for the tool's apparent simplicity, though the brevity comes at the cost of meaningful semantic detail.

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 three required parameters, no output schema, no annotations, and no parameter documentation, the description is too thin to fully equip an agent to call the tool correctly. The agent is left to guess what 'resolved profile' means, what values 'kind' accepts, and what kind of diff result to 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 coverage is 0%, so the description must compensate for the three undocumented parameters. It implies that 'left' and 'right' are the profiles being compared and that 'kind' must match, but it does not clarify what a 'resolved profile' is, how to reference one, what kinds are valid, or the expected input format. This leaves most parameter meaning unresolved.

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—'diff'—and a specific resource—'two resolved profiles of the same kind.' This distinguishes it from profile retrieval (u1_get_profile) and recipe comparison (u1_compare_recipes), though the meaning of 'resolved profiles' is left unexplained.

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

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

No guidance is provided about when to use this tool versus alternatives, nor any conditions or prerequisites. The only implied constraint is that both inputs must be the same kind, but there is no explanation of when diffing profiles is preferable to inspecting or comparing recipes, slices, or runs.

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 states the tool validates and summarizes but does not explain what validation entails (e.g., error behavior, constraints), what the summary contains, or whether it is a read-only operation. The brief wording leaves significant behavioral ambiguity.

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

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

The description is a single, concise sentence that front-loads the core purpose. It is efficient and free of fluff, though its brevity contributes to the lack of behavioral depth.

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 has 4 parameters, no output schema, and no annotations, the description is far too sparse. It does not clarify what 'validate' and 'summarize' produce, how errors are surfaced, or what inputs are acceptable. An agent cannot reliably invoke this tool correctly based on the provided 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%, so the description is the only source of parameter meaning. It names machine, process, and filament but omits nozzle entirely, and provides no detail on expected values, formats, or how parameters relate to the validation/summary logic. The description adds only marginal value beyond the parameter names.

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

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

The description uses specific verbs ('validate' and 'summarize') and identifies the resource ('machine/process/filament selection'), giving a clear sense of the tool's action. It distinguishes itself from siblings like u1_get_profile (which fetches) or u1_diff_profiles (which compares) by implying a validation and summary role, though it does not explicitly contrast with any sibling.

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 u1_get_profile, u1_list_profiles, or u1_diff_profiles. The description does not mention any preconditions, exclusions, or typical scenarios. An agent would have to guess when validation/summarization is needed.

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 implies a file-writing side effect but doesn't disclose whether the report overwrites an existing file, what the report contains, what the return value is, or whether the run must be in a completed state. For a mutation-style operation this is a thin disclosure.

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

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

A single front-loaded sentence with no wasted words. The verb, object, and destination all appear early. It is efficient, though the brevity borders on under-specification rather than deliberate conciseness.

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

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

Incomplete for a tool that performs file output. With no output schema and no annotations, an agent lacks essential information: what the Markdown report contains, the file naming/location convention, whether it overwrites, and how it differs from the plural sibling u1_export_runs_report. Several critical facts are absent.

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 run_id. It doesn't: the description never mentions run_id, a run, or what the report will contain. The parameter name is self-evidently an identifier, but the description adds no semantic detail about how the run is resolved or what output is produced.

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 ('Write'), resource ('a Markdown summary report'), and destination ('into a run directory'). It's clear about what the tool does. However, it doesn't differentiate from the sibling u1_export_runs_report (plural), so an agent can't easily tell them apart without inferring the singular vs. plural distinction.

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

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

No guidance on when to use this tool versus the closely named u1_export_runs_report, nor versus u1_get_run or u1_get_run_logs. There are no usage conditions, exclusions, or alternative routing cues, leaving the agent to guess the correct selection 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 must disclose behavioral traits. It only mentions writing a Markdown report but omits side effects (e.g., file writing vs. returning content), output format details, and any prerequisites. This is a significant gap for a tool likely to have side effects.

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

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

The description is a single, concise sentence that states the core purpose without extraneous detail. It is front-loaded and efficient.

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 output schema and no annotations, the description leaves many critical questions unanswered: what the report contains, how it is delivered, what side effects occur, and what prerequisites exist. The description is far too sparse for an agent 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 description coverage is 0%, and the description does not mention the 'name' or 'run_ids' parameters. The schema defines them, but the description adds no context about their meaning or how they affect the report, leaving the agent without essential semantic information.

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 ('Write') and the resource ('Markdown comparison report for multiple runs'). It distinguishes itself from u1_export_run_report (singular) and other compare tools focused on slices/orientations, though it doesn't elaborate on what 'comparison' entails.

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 u1_export_run_report or u1_compare_*. It only states the action without context, exclusions, or prerequisites.

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

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

With no annotations, the description carries the full burden. It does disclose key behavior: it returns a single, resolved profile using exact-match lookup. However, 'resolved' is left undefined, and there is no mention of not-found behavior or how resolution interacts with profile source chains.

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

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

A single, front-loaded sentence with no filler. Every phrase ('one', 'resolved', 'by exact name or file stem') adds necessary specificity.

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 getter with no annotations and no output schema, the description covers the core retrieval semantics but omits important context such as valid 'kind' values, the meaning of 'resolved', and error behavior. It is adequate but not fully self-sufficient.

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 usefully maps 'name' to an exact profile name or file stem and 'kind' to machine/process/filament profile types. It stops short of giving explicit allowed values or format details, but it provides meaningful guidance the schema lacks.

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 ('Return'), a concrete resource ('one resolved machine/process/filament profile'), and an access method ('by exact name or file stem'). This clearly distinguishes it from sibling tools like u1_list_profiles or u1_profile_source_chain.

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

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

The phrase 'by exact name or file stem' implies this tool is for lookup of a single known profile, but it does not explicitly name alternatives or say when not to use it. Usage context must be inferred from the tool name and sibling list rather than 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. 'Return' implies a read-only operation, but there is no mention of error behavior for unknown names, whether 'built-in' implies immutability, or any other side effects or prerequisites.

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

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

The description is a single sentence with no filler, and the core action is front-loaded. It is concise, though the brevity contributes to the lack of explanatory detail.

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 one-parameter tool, the description is incomplete: it does not explain how to use the name parameter, what the returned recipe contains, or what happens for invalid input. With no annotations and no output schema, more context is needed for correct invocation.

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

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

Schema description coverage is 0%, and the description does not mention the 'name' parameter at all. The agent is left with only the bare schema property and no explanation of what values 'name' should take or where valid names come from.

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 action and object: 'Return one built-in override recipe.' The singular 'one' helps distinguish it from list-oriented siblings like u1_list_recipes and u1_compare_recipes, though it never explains what an 'override recipe' actually is.

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. It does not mention sibling tools, conditions for use, or exclusions, so an agent must infer when this is the right tool to call.

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

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

With no annotations, the description must carry the behavioral burden. It does convey a read-only operation and hints that artifact payloads are not returned ('artifact availability'), but it does not disclose behavior for missing runs, errors, or permission requirements. This is acceptable for a simple getter but not fully 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 a single, front-loaded sentence with no filler. It states the action, the result, and the scope as efficiently as possible.

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 retrieval tool, the description is minimally viable, but it leaves some context unstated: there is no output schema, so the agent must infer what 'compact metadata and artifact availability' looks like, and no guidance is given about how this relates to run listing or searching siblings.

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

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

The schema provides no description for run_id and the description adds little beyond implying that the run is identified by this parameter. The parameter name is self-explanatory, so the low description coverage is only partially compensated; the tool description does not explain formats, uniqueness, or how to obtain a valid run_id.

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

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

The description uses a specific verb ('Return') with a clear resource ('compact metadata and artifact availability') and a definite scope ('for one run'). This distinguishes it from siblings like u1_list_runs, u1_search_runs, and u1_get_run_logs, since it targets a single run and returns metadata rather than logs.

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 about when to use this tool versus related run tools. It implies use for a single run's metadata, but it does not mention alternatives, exclusions, or the relationship to listing, searching, or retrieving run logs.

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 itself must disclose behavior. It does state the core return content (stdout/stderr) and that it only runs on explicit request, which is useful. It omits any edge-case behavior like stream separation, absence of logs, or truncation semantics.

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

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

One terse sentence with no filler, front-loading the action before the qualifier.

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 log-tail tool, run_id and tail are inferable; however, the absence of an output schema and any description of the return format or error behavior leaves gaps. It is minimally viable but not fully complete.

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

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

Schema description coverage is 0%, so the description must compensate. It only weakly hints at parameters: 'one run' implies run_id and 'tails' implies tail, but it doesn't explain tail units, defaulting, or requiredness.

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 clear verb ('Return') and a concrete resource ('stdout/stderr log tails') scoped to 'one run,' so an agent can tell what it does. It doesn't explicitly name a sibling alternative, but the log resource is distinct enough among siblings like u1_get_run and u1_list_runs.

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 or alternative routing is provided beyond the vague phrase 'on explicit request.' It doesn't say when to prefer this over u1_get_run or u1_list_runs, and no exclusions are given.

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

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

With no annotations, the description carries the behavioral burden. It discloses the three areas being checked, which is useful, but it does not describe the output format, whether the check is read-only, or what happens on failure. The verb 'check' implies no mutation, but this is not 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?

The description is a single, well-structured sentence with no filler. It front-loads the action verb and lists the three check targets compactly. Every word contributes meaning, and it is neither verbose nor under-specified in terms of 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 zero-parameter diagnostic tool, the description names the core checked resources, but it lacks any mention of return values, success criteria, or how the results should be interpreted. Given the number of related tools, a brief note on when this health check is relevant would improve completeness. Still, the tool is simple and the scope is mostly covered.

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

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

The input schema has zero parameters, so the description has no parameter semantics to clarify. The baseline for a 0-parameter schema is 4, and this description does not introduce any confusing parameter-related information. No deduction is warranted.

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

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

The description uses the specific verb 'Check' and names three concrete resources: Snapmaker Orca CLI, U1 profile discovery, and output directory access. This clearly identifies the tool's scope and distinguishes it from the many model, profile, slicing, and run-management siblings. It stops short of a 5 because it doesn't explicitly state that this is a pre-flight environment validation 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?

No guidance is given about when to run this tool versus alternatives, nor any indication it should be used before other operations. The description simply states what it checks, leaving the agent to infer the appropriate context. There are also no explicit exclusions or alternatives 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?

With no annotations provided, the description must carry the full behavioral burden. It hints at copy behavior via 'copied G-code file' but does not state side effects, return values, error cases, or whether the original file is preserved. This is a significant gap for a mutation-style tool.

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

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

The description is a single, front-loaded sentence with no filler. It is efficient in form, though its brevity contributes to the lack of behavioral and parameter detail.

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

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

For a 3-parameter tool with no output schema and no annotations, the description is too thin. The agent still needs to infer what gcode/model mean, what the tool returns, and what side effects occur when the preview is injected.

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 adds no explanation of 'gcode', 'model', or 'view'. Bare parameter names are insufficient for an agent to know what values to supply or how they relate to the SVG preview injection.

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 ('Inject') and resource ('SVG preview as comment metadata into a copied G-code file'), making the core action clear. It implicitly distinguishes this from sibling tools like u1_render_preview or u1_slice, though it does not explicitly name alternatives.

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

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

There is no guidance on when to use this tool instead of related tools such as u1_render_preview, u1_slice, or u1_analyze_gcode. The agent is left to infer the appropriate context from the name and one-line description.

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 behavioral disclosure burden. 'Inspect' implies a read-only operation on STL/3MF data, but the description does not disclose failure modes, required model source, output characteristics, or what exactly 'basic U1 fit information' includes.

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, tightly written sentence with no filler. The key resource and purpose are front-loaded, and every word contributes meaning.

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

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

With no annotations, no output schema, and an undocumented parameter, the description is not complete enough for reliable invocation. An agent still lacks critical context: how to provide `model`, what the return shape is, and how results relate to sibling tools.

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

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

Schema description coverage is 0%, and the description does not clarify what the `model` parameter should contain (e.g., a file path, model ID, or reference returned from u1_list_models). The 'STL/3MF' hint weakly implies it is a 3D model, but the parameter semantics remain ambiguous.

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

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

The description states a specific verb ('Inspect'), a specific resource ('STL/3MF dimensions'), and a distinctive scope ('basic U1 fit information'). It is clear on its face, though it does not explicitly distinguish itself from sibling tools like u1_diagnose_model or u1_mesh_printability.

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

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

There is no explicit when-to-use guidance, prerequisites, or mention of alternatives. The description only implies that the tool should be used when inspecting dimensions/fit, but an agent is not told when to prefer this over related inspection 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 behavioral transparency burden. It does add useful scope information: only STL/3MF files inside U1_MODEL_DIR are listed. It does not disclose ordering, recursion behavior, error conditions, or explicitly state that it is read-only, though 'List' implies a non-mutating 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 description is a single front-loaded sentence that states the action, resource type, and location with no filler. Every word contributes meaning.

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 listing tool with an output schema present, the description is nearly complete. It identifies what is listed and where, and the output schema presumably covers return structure. The only missing contextual element is explicit guidance on how this tool fits into a workflow with the many sibling 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 input schema has zero parameters, so the schema coverage is effectively complete. The description does not need to explain parameters, and it correctly adds only resource and location context. Baseline for a zero-parameter tool is 4.

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

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

The description is a specific verb+resource statement: 'List STL/3MF models inside U1_MODEL_DIR.' It names the file types and the directory scope, which clearly distinguishes this from sibling tools like u1_inspect_model, u1_transform_model, or u1_list_profiles.

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: call it when you need to enumerate available STL/3MF models. However, it does not explicitly state when not to use it or point to alternatives such as u1_inspect_model for model details, leaving the agent to infer routing from 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?

No annotations are present, so the description carries the burden. It discloses that default returns names and details=true returns full metadata, which is useful behavioral context. However, it does not mention read-only status, filtering semantics, or output format, leaving significant unknowns.

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

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

The description is a single concise sentence that front-loads the core action and mode. It is efficient and free of unnecessary words, though it sacrifices some parameter information for 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?

With 4 optional parameters, no output schema, and no annotations, the description is insufficient. It does not explain the role of the filter parameters, what 'full metadata' entails, or the structure of the response. An agent would need to guess or inspect further to call 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 coverage is 0%, so the description must explain parameters. It only clarifies 'details' but leaves nozzle, material, and layer_height unexplained. These likely serve as filters, but without guidance, agents may misuse them. The description adds minimal value beyond the schema for three of four parameters.

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 'discovered Snapmaker U1 profile names', and distinguishes it from siblings like u1_get_profile by pluralizing 'profiles'. It also introduces a mode (default vs details) that differentiates behavior.

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 it's used for listing profiles, but does not explicitly state when to use it versus alternatives like u1_get_profile or u1_profile_source_chain. No exclusionary guidance is given, leaving the agent to infer context from the verb 'list'.

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

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

Since no annotations are provided, the description carries the full responsibility. 'List' and 'built-in' convey a read-only, scope-limited enumeration, but the description does not explicitly confirm side-effect-free behavior or describe what the returned data looks like.

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 the verb and resource front-loaded. Every word earns its place, and there is no filler or redundant restatement.

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-argument listing tool, the description is nearly complete: the agent knows what is listed and why. It could be slightly stronger by noting that recipes can later be retrieved via u1_get_recipe or that no arguments are required, but these are minor given the tool's simplicity.

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

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

There are zero parameters and schema coverage is effectively 100%, so there is no parameter burden for the description to carry. The baseline of 4 applies because nothing meaningful is missing 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 names a specific verb ('List'), a precise resource ('built-in override recipes'), and a scope ('common slicing goals'). It is clearly distinguishable from siblings like u1_get_recipe, which fetches a single recipe, and u1_compare_recipes, which compares recipes.

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

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

The description implies this tool is for discovering available override recipes before selecting one, but it never explicitly says when to prefer this over u1_get_recipe or u1_compare_recipes. No exclusions, conditions, or alternative routing are provided.

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 behavioral burden. It only says runs are 'recent' and metadata is 'compact'; it does not disclose ordering, pagination, result shape, or read-only safety beyond the obvious listing behavior.

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

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

A single, front-loaded sentence with no filler. It communicates the core purpose quickly and 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 optional-parameter list tool, the description is minimally sufficient: an agent can infer a listing call with an optional limit. However, with no output schema and no annotation, it would benefit from describing what 'compact metadata' includes or how results are ordered.

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 adds no meaning to the 'limit' parameter beyond what the schema already provides (type integer, default 20). With low coverage, the description was expected to compensate but 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 clearly states a specific action ('List') and resource ('recent generated slice runs'), and 'compact metadata' implies a summary view rather than detailed run inspection. It is distinguishable from siblings like get_run and search_runs, though it does not explicitly name alternatives.

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

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

No guidance is given for when to use this tool versus search_runs, get_run, or get_run_logs. 'Recent' implies a temporal listing, but there are no conditions, exclusions, or explicit mentions of alternatives.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It indicates the operation is an estimation ('estimate') and does not involve slicing, which hints at a non-destructive read-only analysis, but it does not state whether the tool modifies anything, what the output format is, or any limitations of the estimation method. Some behavior is implied but key details are missing.

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 with no filler. The core purpose is front-loaded, and the key differentiator ('without slicing') appears at the end without losing clarity. It is appropriately minimal for a simple tool.

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

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

Given two parameters, no output schema, and no annotations, the description is incomplete. It fails to specify the expected input format for 'model', the role of 'overhang_angle', and the nature of the returned metrics. An agent would need to infer or experiment to use the tool correctly, which is insufficient for reliable invocation.

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

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

Schema description coverage is 0% and the description does not mention either parameter. 'model' is not explained (whether it expects a file path, model ID, or raw data), and 'overhang_angle' is not described as a threshold or criterion. The description adds no value beyond the schema's basic type and default, leaving the agent to guess semantics.

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 'estimate' and identifies the resource as 'STL overhang/contact metrics,' with the explicit qualifier 'without slicing' that differentiates it from sibling u1_slice. However, 'simple' is vague and does not clarify the scope of the metrics, so it is not a perfect 5.

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

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

The phrase 'without slicing' implies this is a lightweight alternative to u1_slice for quick estimates, but it does not explicitly state when to choose this tool over slicing or other analysis tools like u1_diagnose_model. No exclusions or context are provided, so usage guidance is only implicit.

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

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

With no annotations, the description carries the full burden. It discloses a key behavior: it reports and does not enable, indicating a read-only, non-mutating operation. However, it does not mention return format, permissions, or any other side effects, leaving transparency 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 description is a single, front-loaded sentence with no filler. Every word serves a purpose, efficiently conveying the tool's action and 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?

The description is too thin for a tool with an undocumented parameter and no output schema. It does not explain what 'model' means or what the readiness report contains, so an agent cannot fully predict invocation or result.

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 one optional parameter 'model' with 0% schema description coverage. The description completely omits this parameter, providing no guidance on what to pass or how it affects the report. It fails to compensate for the schema's lack of parameter information.

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 identifies the resource as 'multi-material support/readiness', clarifying that it does not enable it. This clearly distinguishes the tool from a hypothetical enabling tool and gives a precise purpose.

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 a clear context: use it when you need to report multi-material readiness without making changes. The phrase 'without enabling it' implies it is not for enabling, but it does not explicitly name sibling alternatives or conditions for non-use.

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

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

Annotations are absent, so the description carries the full burden. It says 'without slicing rotated variants' suggesting a pre-check, but does not disclose whether the tool is read-only, what it returns, or any side effects. It doesn't clarify if it validates, reports, or modifies state—a significant gap for a tool with no annotation support.

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 wasted words. It immediately states the core action and the key differentiator ('without slicing'), achieving maximum conciseness.

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

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

Given one parameter, no output schema, no annotations, and a terse description, the tool is underspecified. It doesn't explain what 'preflight' outputs or how it relates to the workflow of siblings like u1_slice and u1_compare_orientations. An agent cannot determine the expected result or prerequisites.

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 adds no meaning to the 'model' parameter. No format, purpose, or examples are given, leaving the parameter ambiguous despite being the only one. Since it's the sole input, the description should have elaborated on what 'model' refers to.

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 'preflight' and resource 'axis-aligned orientation candidates', and explicitly differentiates from slicing tools by noting 'without slicing rotated variants'. This distinguishes it from siblings like u1_slice and u1_compare_orientations without needing to open schemas.

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

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

The description implies a lighter alternative to full slicing but does not explicitly state when to use this tool versus siblings. It lacks guidance on conditions or alternatives, leaving the agent to infer the intended context from the phrase 'without slicing rotated variants'.

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 at least indicates a read-style operation by saying 'Return' and discloses the child-to-parent direction, but it does not explain how name and kind identify the profile, what happens when a parent is missing, or what the chain elements contain.

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

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

The description is a single sentence with no filler and the core action is front-loaded. It loses a point because 'source chain' is somewhat jargon-heavy, but overall it is compact and efficiently worded.

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

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

The tool has no annotations, no output schema, and 0% parameter description coverage, so the one-line description is the only guidance available. It is far too sparse to allow an agent to correctly construct the required parameters, interpret the result, or choose this tool over the many profile-related siblings.

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

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

The schema has 0% description coverage, so the description must compensate, but it never mentions 'name' or 'kind'. The word 'profile' hints that one parameter identifies a profile, but 'kind' is completely unexplained, leaving an agent unable to determine valid values or how the parameters relate.

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 returns the child-to-parent profile inheritance source chain. It also gives the traversal direction, which adds specificity beyond the tool name. However, it does not explicitly differentiate itself from sibling tools like u1_get_profile or u1_explain_profile_selection.

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 instead of u1_get_profile, u1_diff_profiles, or u1_explain_profile_selection. No conditions, prerequisites, or exclusions are provided.

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 must carry the full burden of behavioral disclosure. It only says 'generate a lightweight SVG preview,' which implies a read-like operation but does not disclose potential side effects, performance characteristics, output format details, or any constraints. It lacks transparency about what the tool actually does beyond its stated purpose.

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

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

The description is a single, front-loaded sentence with no redundant words. It is appropriately concise for the amount of information it conveys. However, it is so minimal that it barely earns its place; a slightly more detailed but still efficient description would be more valuable.

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 two parameters, no annotations, and no output schema, the description is far from complete. It fails to explain the view parameter, the expected model format, any return value structure, or any usage constraints. An agent would likely need to guess or call other tools to understand how to invoke this correctly.

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

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

The input schema has two parameters (view and model) with zero description coverage, so the description must compensate. It mentions 'model dimensions' but does not explain what the model parameter expects (e.g., format, path) or what the view parameter controls (default 'summary'). This is insufficient for an agent to correctly supply valid arguments.

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 verb ('Generate') and a concrete deliverable ('lightweight SVG preview'), with an explicit input ('from model dimensions'). This distinguishes it from sibling tools like u1_inspect_model (which inspects) or u1_render_preview_bundle (which likely bundles previews). The phrasing is precise and unambiguous.

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

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

No guidance is given on when to use this tool versus alternatives. It does not mention any conditions, prerequisites, or scenarios where a different tool would be more appropriate. Given the large sibling list (e.g., u1_inject_thumbnail, u1_render_preview_bundle), an agent receives no help choosing among them.

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 present, so the description bears the full burden of behavioral disclosure. It only states what is generated, not whether the operation is read-only, whether any files are created or modified, what inputs are expected, what the output bundle looks like, or any side effects. For a no-annotation tool, this is a notable 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 description is a single, well-structured sentence with no filler. It front-loads the action and enumerates the outputs efficiently, which is ideal for quick agent scanning.

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

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

The tool has no output schema and no annotations, so the description should explain what the agent receives and how the bundle is returned. It names the types of previews but not the structure, format, or whether they are returned inline, as files, or as URLs. The lack of differentiation from sibling tools further weakens its 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?

With schema description coverage at 0%, the description must compensate, but it only says the action is 'for a model.' It does not clarify what 'model' should contain—an ID, name, path, or object—nor any constraints or accepted formats. This adds almost no meaning beyond the parameter name itself.

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 ('Generate'), a target resource ('a model'), and concrete outputs ('summary/top/front/side SVG previews'). It is not an explicit differentiation from the sibling 'u1_render_preview', but the listed views and the word 'bundle' imply a multi-preview tool, which helps an agent distinguish it.

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 about when to use this tool instead of related siblings like 'u1_render_preview', 'u1_inject_thumbnail', or 'u1_inspect_model'. There is no description of conditions, prerequisites, or exclusions, so the agent must infer when this tool is the right choice.

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

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

With no annotations, the description must carry the safety and behavior burden, but it only implies that stored metadata is used and does not disclose whether this executes a new slicing run, writes output, or has side effects. It also does not mention what happens for non-regular runs or missing run IDs.

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 words. It is concise, though its brevity is partly a cause of the missing behavioral detail.

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

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

With no output schema and no annotations, an agent is left without information about return values, failure modes, or the semantics of 'regular run'. The one-sentence definition is enough to identify the tool but not enough to invoke it with confidence.

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 compensate. 'run_id' can be inferred from 'previous run', but 'verbose' is never explained, and neither parameter is described in terms of accepted values or effects.

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 concrete verb ('re-slice') and a resource ('previous regular run'), and adds a distinctive source ('stored request metadata'), so an agent can tell this is about reproducing a run rather than creating a new slice. It is still missing a definition of what counts as a 'regular run', but the core purpose is clear.

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

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

There is no explicit guidance about when to choose this tool over u1_slice, u1_smoke_slice, or u1_get_run. 'Re-slice a previous regular run' states the purpose but does not describe the condition for using it or name 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 must carry the behavioral disclosure. The verb 'Search' implies a read-only query and 'recent' scopes the time window, which is useful. However, it does not define 'recent', ordering, pagination, or whether the search matches partial values, so behavioral detail is incomplete.

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 communicates the tool's purpose and core filter parameters with no filler. 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?

Despite low conceptual complexity, there is no annotation and no output schema, so the description must cover recent-window semantics, allowable filter values, and result expectations. It covers none of these, making it incomplete for reliable 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%, yet the description only restates the self-evident filter names (model, filament, status) and omits the limit parameter. It adds no detail about valid status values, matching semantics, or how limit affects results, so it does not compensate for the schema's silence.

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 (search) on a specific resource (recent runs) with explicit filter dimensions (model, filament, status). It is clear, though it does not explicitly contrast itself with sibling u1_list_runs, so it stops short of full 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?

There is no guidance on when to choose search_runs over alternatives such as u1_list_runs or u1_get_run. The intended use case (filtered discovery of recent runs) is only implied by the phrase 'by model, filament, and/or status'; no exclusions or competing-tool routing are provided.

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 reveals the output type (compact G-code analysis) and the verbose logging option, but omits side effects, compute time, file outputs, error conditions, or any prerequisites. This is minimal disclosure for a slicing 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 description is a single, front-loaded sentence that efficiently states the core action and a key flag. It is appropriately concise, but its brevity comes at the cost of necessary detail for a tool with this parameter complexity.

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 7 parameters, 0% schema description coverage, no annotations, and no output schema, the description is severely incomplete. It does not explain the meaning of required parameters, the structure of the returned analysis, or any prerequisites. An agent cannot reliably call this tool correctly based on 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 coverage is 0%, so the description must compensate by explaining parameters. It only hints at 'model' and 'verbose', while the required 'process' and 'filament' and optional 'nozzle', 'overrides', and 'orientation' are entirely unaddressed. This leaves agents guessing about critical inputs.

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 (slice), the resource (STL/3MF model), and the target device (Snapmaker U1), and specifies the output as 'compact G-code analysis'. This distinguishes it from analysis-only tools like u1_analyze_gcode, though it does not explicitly name sibling alternatives.

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

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

No guidance is provided on when to use this tool versus siblings such as u1_smoke_slice or u1_compare_slices. The only usage note, 'set verbose=true for logs', is a flag behavior, not a selection criterion, and does not help an agent decide between 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?

No annotations are provided, so the description carries the full burden. It says 'Run' which implies execution/side effects, but doesn't disclose whether this writes files, requires a connected printer, has side effects on runs, or what 'smoke slice' means behaviorally. The term 'real' hints at non-mock behavior but is vague.

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

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

Single sentence, no waste, and the key qualifier 'Phase 0 real smoke slice' is front-loaded. It earns its place, though it could add a bit more context without becoming bloated.

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 5 parameters, 0% schema coverage, no annotations, and no output schema, the description is too thin. An agent doesn't know what 'smoke slice' produces, whether it's safe, or how it differs from u1_slice. The sibling list shows many related tools, and this description doesn't position itself among them.

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 mentions 'process and filament profiles' which maps to the process and filament parameters, but doesn't explain model, nozzle, or verbose semantics. The description adds minimal meaning beyond the schema's parameter names.

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

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

The description states a specific verb ('Run') and resource ('Phase 0 real smoke slice') with explicit process and filament profiles. It distinguishes from siblings like u1_slice by specifying 'Phase 0 real smoke slice', though it doesn't explicitly name the alternative.

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

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

The description implies this is for running a smoke test slice with explicit profiles, which suggests a testing/validation context. However, it doesn't explicitly state when to use this vs u1_slice or other slicing tools, nor does it mention prerequisites like model validity or profile availability.

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 behavioral burden. It does disclose that the operation creates a copy locally and where it lands, implying the original STL is not modified. However, it does not mention whether existing files are overwritten, what the output filename is, whether the operation has side effects, or what the tool returns.

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

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

The description is one concise sentence with no filler. It front-loads the action and output location, making it easy to read and 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, no output schema, and four parameters with zero description coverage, the description is incomplete for confident invocation. An agent would still need to infer rotation semantics, output naming, and whether the operation is safe or destructive in any way.

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

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

The input schema has 0% description coverage and the description adds no meaning to the parameters. The word 'transformed' hints at the rotation parameters, but the description does not explain the units, the relationship among rotate, rotate_x, and rotate_y, or what values are valid for the required 'model' 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 uses a specific verb ('Create') and a clear resource ('a locally transformed STL copy under U1_OUTPUT_DIR/transformed'). It distinguishes the tool's core action from siblings like u1_inspect_model and u1_slice, though it does not explicitly differentiate it from other transform-related 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?

There is no guidance about when to use this tool versus alternatives such as u1_compare_transformed_orientations or u1_slice. The description states what the tool does but provides no context, preconditions, or exclusions, leaving the selection decision to the agent.

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