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

With no annotations provided, the description must fully disclose behavioral aspects. It explains the operation (deblurring) but omits critical details such as whether the input image is modified, the nature of the output dictionary, error handling, or any side effects. The phrase 'Returns dictionary with deblurring results' is vague and doesn't specify keys or structure. This is 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 well-organized with an Args section and a Returns section. It is concise, with no filler, and the main purpose is front-loaded. It is not overly verbose for six parameters, and the structure aids readability. Slight deduction for repeating parameter names in the documentation format, which is standard.

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

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

Given the tool's complexity (6 parameters, multiple model choices), the description is inadequate. It does not explain the difference between deblur_cyto2 and deblur_cyto3 models, the meaning of 'channels' in this context, or how to interpret the returned dictionary. While it has an output schema (per context signals), its content is not repeated in the description. The tool is not fully usable by an agent without guesswork.

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

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

Schema description coverage is 0%, so the description must compensate. It does: each parameter is listed with a brief but meaningful explanation (e.g., 'model_type: Restoration model type (deblur_cyto2, deblur_cyto3, etc.)' and 'diameter: Expected object diameter for scaling'). It adds value by clarifying the purpose of each parameter, even if it doesn't fully explain the 'etc.' or exact formats.

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

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

The description clearly states the tool 'Deblur a microscopy image using Cellpose restoration models', which is a specific verb and resource. It differentiates from siblings like denoise_image and upsample_image by using the term 'deblur', though it doesn't explicitly contrast with them. The purpose is clear and unambiguous for an agent.

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 does not mention when to use this tool versus alternatives such as denoise_image or restore_and_segment. It provides no context on selecting between deblurring and other restoration methods, nor does it explain prerequisites or conditions. An agent would have to infer usage from the tool name and model_type parameter.

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 supplied, so the description carries the full behavioral burden. It does disclose a Returns dictionary with denoising results and documents model_type options, but it never states side effects: whether output_path is auto-generated when omitted, whether the input file is ever overwritten, or whether on-disk model weights must be downloaded on first run.

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?

Docstring format with a one-line purpose leading, followed by a compact args table and a short Returns section. Each element earns its place with no redundancy, though some glosses (e.g., 'channel specification') could be tightened without losing value.

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

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

For a 6-parameter, 0% schema-coverage tool, the description covers purpose, every parameter, and the return value shape. Since an output schema exists, spelling out the exact dictionary keys is unnecessary. Remaining gaps are runtime behaviors (auto-save behavior, model downloads), which an agent cannot infer.

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

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

With 0% schema description coverage, the description compensates by enumerating all six parameters with meaningful glosses—model_type even lists concrete choices (denoise_cyto2, denoise_cyto3). A few entries remain vague ('channels: Channel specification', 'diameter: Expected object diameter for scaling'), leaving exact formatting to the schema.

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

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

States the exact operation (denoise), the resource (microscopy image), and the method (Cellpose restoration models) in the opening line. This immediately distinguishes it from siblings like deblur_image, upsample_image, and the segment_cells_* family, which perform different operations.

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

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

Never states when to prefer denoising over the sibling restoration tools (deblur_image, upsample_image) or lists any alternatives. No exclusions, prerequisites, or selection criteria are given—usage is only implied by the tool's own name.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states it returns a dictionary with estimated diameter and confidence, but does not mention side effects, errors, or operational constraints (e.g., whether it reads-only, modifies files, requires GPU specifics). Since annotations are absent, this is a significant gap.

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

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

The description is well-structured with a clear purpose statement, an Args section, and a Returns section. It is concise and front-loaded with the main action. No redundant or verbose text. The docstring style is appropriate and aids readability, earning a high score for structure.

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 4 parameters, no annotations, and an output schema that is not provided (though indicated to exist), the description is not complete. It does not explain how to interpret the returned dictionary (keys, units, confidence meaning), nor does it mention any requirements like cell vs nuclei models or image dimensionality. An agent would likely need to explore sibling tools or test cases to use this effectively.

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 coverage is 0%, so the description must compensate. It provides one-line descriptions for each parameter, but these are mostly tautological (e.g., 'model_type: Model type to use for estimation') and do not specify valid values, formats, or relationships. For instance, 'channels: Channel specification' is vague, and no default values or examples are given. This is insufficient for an agent to choose correct parameter values confidently.

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

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

The description clearly states the tool estimates cell diameter using the Cellpose size model. It uses a specific verb and resource, and the purpose is distinct from sibling tools like segmentation or denoising. However, it does not explicitly differentiate from potential overlap with segmentation tools that might also provide size information, so it isn't 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?

No guidance is provided on when to use this tool versus alternatives. There is no mention of scenarios where diameter estimation is preferred over segmentation, or any preconditions like image type or size. The agent is left to infer usage from the description alone, which is minimal.

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

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

With no annotations, the description carries the full burden. It discloses the return format (a dictionary of lists by category), which is useful. However, it does not state that this is a read-only operation, whether it requires network access, or if results are cached. The behavioral disclosure is minimal but not misleading.

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

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

The description is a crisp two-sentence summary with no wasted words. The purpose is front-loaded, and the return format is stated in the second sentence. Every word earns its place, making it highly efficient for an agent to parse.

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

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

Given the tool's simplicity (no parameters, output schema provided), the description is largely complete. It explains the return structure, and the output schema covers the detailed categories. It might benefit from a hint about typical usage, but overall it suffices for a straightforward listing operation.

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

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

The tool has zero parameters, so the baseline is 4. The description adds no parameter-related information, but none is needed. The schema is already fully covered, and the description correctly omits any irrelevant parameter details.

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 ('list') and resource ('available pretrained Cellpose models'), clearly distinguishing it from siblings like segment_cells_2d and denoise_image, which perform transformations rather than enumeration. The purpose is unambiguous and immediately understandable.

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

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

No guidance is provided on when to use this tool relative to alternatives. It does not mention that this should be called before segmentation to discover model names, nor does it exclude any contexts. An agent must infer usage from the name alone, which is insufficient for explicit routing.

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. It implies a read operation ('get information') and lists the return fields, but does not disclose whether the file is read from disk, what happens on missing/unreadable files, supported formats, or that it does not modify the file. The read-only nature is only inferred from the word 'information.'

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

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

The description is extremely concise and front-loaded. The primary purpose appears in the first sentence. The Args/Returns structure is clear and adds no repetition or fluff. Every sentence earns its place.

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

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

Given the tool's simplicity (one parameter, no nested objects) and the presence of an output schema, the description is reasonably complete. It states the parameter and the high-level return type. Minor gaps include error handling and supported formats, but these are not critical for a metadata loader and are partially covered by the output schema.

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 defines 'image_path' as 'Path to image file,' which adds meaning beyond the raw string type in the schema. Though not detailed (e.g., relative vs absolute, format support), it provides the essential meaning for the only 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?

States a clear verb-resource pair: 'Get information about an image file.' It specifies the output is a dictionary with metadata (shape, dtype, channels, dimensions). It is distinct enough from the sibling tools, which are all processing/segmentation tools, but the description does not explicitly contrast them.

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 over alternatives. It does not mention conditions like needing metadata before segmentation, nor does it exclude scenarios where other loaders might be preferred. The description is purely functional with no contextual 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?

Since no annotations are provided, the description carries the full burden. It only mentions that the tool returns a 'Dictionary with combined restoration and segmentation results' and lists parameters, but fails to disclose behavioral traits such as side effects (writing files), permissions, GPU requirements, or return structure details.

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

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

The description is efficient: a one-sentence summary followed by a clearly labeled Args/Returns section. There is no fluff, and the essential information is front-loaded, making it easy to scan.

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 8 parameters and an output schema (not detailed), yet the description only provides a brief mention of the return type. It lacks detail on the dictionary keys, model dependencies, or prerequisites. For a complex pipeline, this is insufficient for an agent to invoke it correctly without additional context.

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

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

Schema description coverage is 0%, so the description must compensate. It provides one-line descriptions for each parameter (e.g., 'image_path: Path to input image'), which adds basic meaning, but some entries like 'channels: Channel specification' are vague. The descriptions are minimal but present.

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 that the tool restores (denoise/deblur) and segments an image in one pipeline. This is specific and differentiates from siblings that do only one task, though it does not explicitly name them.

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 using separate restoration or segmentation tools. There is no mention of conditions like 'use this when both restoration and segmentation are needed' or alternatives, leaving the agent to infer the 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 fully discloses key behaviors: always writes three outputs, with each output type specified; explains the role of image_path (overlay drawn on it if provided); flags save_flows as reserved for future use; and describes the return dictionary. This is comprehensive and leaves little to inference.

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 well-structured with a clear purpose statement followed by an Args section and a Returns line. It is not overly verbose and front-loads the main functionality. Minor redundancy (e.g., restating 'three outputs' in the purpose and the list) is acceptable and does not hurt 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?

For a save tool with 5 parameters and no schema coverage, the description is complete: it covers the purpose, all parameters, the return structure, and the side effects (always writes three files). It does not leave critical gaps that an agent would need to guess.

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

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

Schema description coverage is 0%, so the description must explain all parameters. It does: each parameter is briefly described in the Args section, including the meaning of output_path, image_path, and save_flows. This adds significant meaning beyond the bare schema types and defaults.

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 ('save') and resource ('masks'), and explicitly lists the three outputs it produces (masks, outlines, overlay). This clearly differentiates it from sibling tools that segment, denoise, or restore images, so an agent can immediately identify its 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 implies usage for saving masks after segmentation, but it does not explicitly state when to use it vs. alternatives or provide exclusion criteria. However, the sibling tool names make the context obvious, and the description clearly indicates this is the saving step. A clear conditional statement would improve it, but it is adequate.

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 disclosure burden. It does disclose the return dictionary shape and the output_path default side effect ('image_path with _masks suffix'), which shows the tool writes files. However, it omits runtime behaviors an agent would need to anticipate, such as first-use model download, GPU memory requirements, or failure modes for unsupported image formats. Partial but meaningful 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?

Well structured with an opening sentence, an Args block, and a Returns block. Though long, every line documents a parameter that is otherwise undocumented in the schema, so no content is wasted. The purpose statement is front-loaded before the parameter list. Appropriate length for a 12-parameter tool.

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

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

For a complex 12-parameter segmentation tool with 0% schema coverage, the description thoroughly covers all parameters and their semantics. An output schema exists, so return-value details need not be repeated. The main gap is the missing usage guidance relative to siblings, which is a separate dimension. Parameter and behavioral coverage is otherwise 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%, and the description fully compensates by documenting all 12 parameters with semantic context. It explains tuning-direction effects ('flow_threshold: lower = more masks, may be worse quality'), defaults ('diameter: 0 = model default'), and channel semantics ('[cyto, nuclei] or None for grayscale'). This exceeds what the bare schema names and defaults could convey.

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?

Opens with a specific verb+resource statement: 'Segment cells in a 2D microscopy image using Cellpose.' The '2D' qualifier distinguishes it from sibling segment_cells_3d, and the single-image framing differentiates it from segment_cells_batch. Purpose is unambiguous.

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

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

The description provides no explicit when-to-use guidance or alternative routing. Sibling tools like segment_cells_3d, segment_cells_batch, and restore_and_segment are never mentioned, so an agent must infer scope from the name. The parameter hints (e.g., 'Expected cell diameter in pixels') subtly reference related tools but never say 'use estimate_cell_diameter first' or 'use segment_cells_batch for multiple images.'

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions a side effect (output_path saves masks) and that a dictionary is returned, but it omits details about GPU usage implications, potential errors, resource requirements, or the structure of the returned dictionary. For a compute-heavy segmentation operation, this is inadequate.

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 well-structured docstring with clear Args and Returns sections. It is not verbose, and the main purpose is stated upfront. Each parameter description is concise and scannable.

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

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

With 10 parameters, no annotations, and only a vague output description ('dictionary with 3D segmentation results'), the description lacks essential context. It does not explain the keys in the returned dictionary, error handling, installation prerequisites, or how to interpret results. It also fails to guide the agent on choosing between this and closely related siblings, leaving critical gaps.

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

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

Schema description coverage is 0%, so the Args section is the only documentation for parameters. It provides meaningful semantics for each parameter (e.g., 'do_3d: Use full 3D segmentation (True) or slice + stitch (False)' and 'anisotropy: Z-axis anisotropy factor'). While a few descriptions are vague (model_type), overall it adds value beyond the bare schema.

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

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

The description states a specific verb ('Segment') and a clear resource ('cells in a 3D volume') while naming the method (Cellpose). It directly distinguishes from siblings like segment_cells_2d (2D vs 3D) and segment_cells_batch (batch), so the agent can differentiate immediately.

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

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

No explicit guidance is provided on when to use this tool versus alternatives. The description only explains parameters (e.g., do_3d) but does not state when to prefer 3D over 2D, when to use batch mode, or any prerequisites. This leaves the agent to infer usage context from sibling names.

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

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

With no annotations provided, the description carries the full burden of disclosing behavior. It mentions saving masks implicitly via the output_dir parameter but does not state that files will be written to disk, nor does it disclose GPU usage, potential side effects, or error behavior. The description is mostly a restatement of the parameter list, adding little beyond the schema.

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

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

The description is concise, uses a clear list format for arguments, and includes a return type line. It is front-loaded with the core purpose and avoids fluff. Slightly more could be added about side effects, but the structure is efficient and scannable.

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

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

Given the tool's complexity (6 params, batch processing) and the presence of an output schema, the description is minimally adequate but lacks context on when to prefer this tool, error handling, resource requirements (e.g., GPU necessity), and what the returned dictionary contains. The output schema covers return structure, but overall context for safe and correct usage is incomplete.

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

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

Schema description coverage is 0%, so the description must compensate. It does provide brief explanations for each parameter (e.g., 'image_paths: List of paths to input images'), adding meaning beyond the schema's type definitions. While not deeply detailed, it covers all six parameters and clarifies their purpose, meeting the compensation need.

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 combination ('Segment cells in multiple images in batch') and clearly distinguishes from siblings like segment_cells_2d and segment_cells_3d by emphasizing batch processing. It is immediately obvious what the tool does and how it differs from single-image counterparts.

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

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

No explicit guidance is given on when to use this tool versus alternatives. The sibling names suggest single-image segmentation, but the description does not state 'use for multiple images' or 'for single images use segment_cells_2d/3d'. Context is implied by the word 'batch' but not stated as a decision rule.

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 exist, so the description carries the full disclosure burden. It does disclose inputs, GPU toggle, default output location, and return format ('Dictionary with training results'). However, it omits operational traits important to a training job — expected runtime/resource intensity, whether training blocks or runs asynchronously, and whether input data is modified. Partial but not rich 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?

The core purpose is front-loaded in a single sentence before the Args block. Given 11 parameters and zero schema coverage, the docstring listing is justified — each line is a short, meaningful explanation with no filler. It might be condensed slightly, but the length is proportionate to the documentation burden.

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

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

The description covers all parameters and return format, and the output schema exists so return details need not be repeated. However, for a complex training tool with no annotations, it misses prerequisites such as expected mask/label data format and naming conventions that must match training images, plus initial model availability. Adequate but with gaps an agent would need for a first 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 coverage is 0%, so the description must compensate — and it does. The Args section gives each of the 11 parameters a meaningful one-liner (e.g., 'Base model type (cyto, nuclei, etc.)' offers concrete valid values; 'test_dir: Optional directory with test images' conveys optionality). All parameters are explained beyond their bare names, though entries are brief and lack format details like accepted file extensions.

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?

'Train a custom Cellpose segmentation model' uses a specific verb (train) and specific resource (custom Cellpose model). It clearly differentiates from siblings like `segment_cells_2d`/`3d`/`batch` (inference), `denoise_image`/`deblur_image` (image restoration), and `list_available_models` (model listing). An agent can distinguish this tool without opening 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?

No explicit guidance states when to use this tool versus alternatives, nor when NOT to use it. Usage is only implied by the verb 'train'. It never mentions that `list_available_models` could be checked first or that `segment_cells_*` handles inference from pre-trained models, so the agent gets no routing cues.

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 fully disclose behavioral traits. It mentions GPU acceleration and optional output path but does not disclose prerequisites, potential side effects (e.g., file writing), or the structure of the returned dictionary. The description is sparse on details like error handling, model availability, or whether the operation is read-only, leaving significant 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 well-structured docstring with clear Args and Returns sections. It is not overly verbose and front-loads the purpose. Minor redundancy exists (e.g., repeating 'upsampling' in multiple places), but it remains concise and readable.

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

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

Given the tool's complexity (6 parameters, no annotations, and no explicit output schema details), the description is incomplete. It lacks critical context such as the exact format of the return dictionary, how to choose among model_types, the expected channels format, and any prerequisites or limitations. An agent may struggle to use this tool correctly without additional information.

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

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

Schema description coverage is 0%, so the description must compensate. It provides useful hints for some parameters (e.g., scale_factor 'typically 2 or 4', model_type examples) but leaves others vague (e.g., channels: 'Channel specification' without format or allowed values). It adds some value over the bare schema but does not fully clarify all six 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 a specific action (upsample) on a resource (microscopy image) using Cellpose restoration models. It distinguishes from sibling tools like denoise_image and deblur_image by its focus on upsampling, making it clear what this tool does and how it differs.

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 does not provide any guidance on when to use this tool versus alternatives. It does not mention any conditions, scenarios, or comparisons to sibling tools. An agent would have to infer usage from the name and general knowledge, as no explicit selection criteria are provided.

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