Atlarium Habitat Database MCP

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

Annotations already declare the tool as read-only, idempotent, and non-destructive. The description adds only the word 'advisory,' which hints at recommend output, but provides no further behavioral context such as assumptions, formulas, or edge-case handling. This is minimal additional transparency beyond what annotations already cover.

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 efficiently communicates the tool's scope without unnecessary 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?

The tool has three nested input objects and an output schema, so some complexity is present. The description is minimal but adequate, covering the main categories. However, it could be improved by stating the advisory nature and explaining what the outputs represent, though the schema compensates for most 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?

The input schema has complete (100%) description coverage for all nested objects and properties, so the baseline is 3. The description simply names the three categories (heater, lighting, electricity) and does not add parameter-level meaning beyond the schema.

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

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

The description clearly states the tool calculates heater, lighting, and electricity requirements, using the verb 'calculate' and naming specific resources. It distinguishes from sibling calculators by naming these three equipment types, though it could be more explicit about the advisory/recommendation nature.

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. The description implies usage for equipment calculations but does not mention exclusions, prerequisites, or alternative tools, leaving the 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.

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering safety and side effects. The description adds useful behavioral context by noting the dose is 'advisory' (a recommendation, not a guaranteed prescription) and limited to 'public catalog products,' which constrains applicability. This goes beyond the annotation-provided information without contradicting it.

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 redundant words. It front-loads the primary action and resource, and every word earns its place by conveying purpose, scope, and output type.

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

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

Given the tool's low complexity, full schema parameter descriptions, rich annotations, and presence of an output schema, the description is complete enough for an agent to understand inputs and safety. It could have elaborated on the returned structure, but the output schema covers that, so no significant gap exists.

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 100%, so the baseline is 3. The description names 'public catalog product' and 'tank volume,' which map to product_name and volume_liters, but does not add additional detail beyond what the schema already provides for each parameter. The optional brand_name is not mentioned in the description, but the schema documents it adequately.

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 'calculate' and the resource 'advisory fertilizer dose' for a specific product and tank volume. It distinguishes from sibling tools like calculate_equipment_requirements and calculate_tank_volume, though it does not explicitly name alternatives. The scope is specific enough to be 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 guidance on when to use this tool versus alternatives such as calculate_weekly_dose_totals or generate_fertilization_plan. It lacks explicit when/when-not or alternative recommendations, leaving the agent to infer usage from the tool name and description alone.

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

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

Annotations already declare readOnlyHint and idempotentHint, but the description adds a specific behavioral guarantee: 'without saving user data'. This is a meaningful addition because it clarifies that no persistent state is created, which goes beyond the generic read-only annotation. No contradictions with annotations.

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

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

The description is a single, well-structured sentence that front-loads the core purpose and includes a meaningful qualifier about data persistence. It contains no filler or redundant information, making it highly concise.

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

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

Given the tool's complexity (six parameters, nested objects, optional targets/measurements) and the presence of an output schema, the one-line description is somewhat sparse. It omits any guidance on when to use the tool in the broader context of sibling nutrient/fertilizer tools. However, the schema and annotations provide substantial context, so the description remains minimally adequate.

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

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

The schema description coverage is 100%, so all six parameters have detailed descriptions in the schema. The description does not add any information about parameter semantics beyond what the schema already provides. It does not clarify how targets and measurements interrelate, which is a minor gap, but the schema covers individual 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 tool's function with the verb 'Compare' and identifies the resources ('nutrient targets' and 'supplied measurements'). It also adds a key attribute ('without saving user data') that clarifies its side-effect-free nature. However, it does not explicitly differentiate from sibling calculation tools like calculate_water_chemistry or calculate_fertilizer_dose.

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

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

The description provides no explicit guidance on when to choose this tool over alternatives. It implies use when comparing targets to measurements, but there are no usage scenarios, prerequisites, or exclusions. Sibling tools such as calculate_water_chemistry and generate_fertilization_plan are not referenced.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds the behavioral distinction between 'gross' and 'net' estimates and the word 'estimates' signaling approximate results. No contradictions with annotations.

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

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

The description is a single, concise sentence that is front-loaded with the action and resource. Every word earns its place, with no unnecessary detail or repetition.

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

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

The tool has 11 parameters and shape-specific logic (rect, cyl, bow), but the description lacks guidance on how to select dimensions per shape. However, the schema's parameter descriptions and the existing output schema compensate partially, making the description minimally adequate.

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?

All 11 parameters have descriptions in the input schema (100% coverage), so the baseline is 3. The description only mentions 'dimensions' generically and does not add any parameter-specific meaning beyond what the schema already provides.

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

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

The description clearly states the tool's purpose with a specific verb ('Calculate'), resource ('aquarium volume'), and scope ('gross and net... from dimensions'). It distinguishes itself from sibling calculators like calculate_tank_weight and calculate_water_change by focusing on volume estimates.

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 'from dimensions' implies the tool is used when dimensions are available, but it provides no explicit guidance on when to use this tool over alternatives such as calculate_tank_weight. No exclusions or alternative tool references are given, so usage context is only implied.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, so the agent knows this is a safe, read-only operation. The description adds the term 'advisory', indicating the output is an estimate rather than exact, which is useful. However, it does not disclose calculation assumptions, limitations, or how the shape parameter affects required inputs beyond what the schema already provides.

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 of ten words, front-loaded with the verb 'Calculate'. Every word is informative and there is no redundancy or filler. It is optimally 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?

The tool has 16 parameters and a shape enum that determines which measurements are relevant, but the description does not explain this conditional complexity. However, the output schema exists and each parameter has a description, so the agent can infer usage from the schema. The description is minimally complete but could benefit from explaining that certain parameters apply only to specific shapes, which is a notable gap.

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 100%, with each of the 16 parameters having a descriptive comment. The tool description only summarizes inputs as 'dimensions and material inputs', which adds no new meaning beyond the schema. Baseline 3 is appropriate because the schema carries the full burden of parameter 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 the specific verb 'calculate' with the resource 'tank weight' and qualifies it as 'advisory estimates' from 'dimensions and material inputs', clearly distinguishing it from sibling tools like calculate_tank_volume. The purpose is immediately apparent 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?

The description does not specify when to use this tool versus alternatives such as calculate_tank_volume or calculate_water_chemistry. It only implies usage for weight estimation, but there is no explicit guidance on selection criteria, prerequisites, or cases where another tool is more appropriate.

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

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

Annotations already declare readOnly, idempotent, and non-destructive hints. The description adds minimal behavioral context beyond stating the calculation outputs; it does not describe edge cases, assumptions, or limitations, but the annotation coverage lowers the burden.

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

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

The description is a single, front-loaded sentence that directly conveys the tool's purpose with no redundant words. Every phrase adds value.

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

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

The tool has an output schema and the description combined with full parameter descriptions provides enough context for a straightforward calculation tool. However, it lacks explicit guidance on how inputs relate to the three output types, which is a minor gap.

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?

All parameters have descriptive schema entries with ranges and units (e.g., volume_liters, change_percent, changes_per_week). The tool description does not add further parameter-specific meaning, so with 100% schema coverage, the baseline of 3 is appropriate.

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 ('Calculate') and resource ('water change volume, weekly totals and dilution estimates'), clearly distinguishing it from sibling tools like calculate_tank_volume or calculate_weekly_dose_totals.

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 water change calculations but does not explicitly state when to use this tool over siblings or provide exclusions. The name and description make the use case clear, but no alternatives or when-not scenarios are mentioned.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds only that outputs are 'estimates,' which is mild behavioral context; it does not describe result shape or edge cases.

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, grammatically simple sentence with all key terms front-loaded; no redundant or filler content.

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

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

With an output schema, rich annotations, and full parameter descriptions, the one-sentence description suffices to convey the tool's scope. It could be slightly more explicit that the caller should provide one of the sub-objects, but the schema already reveals that structure.

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 100%, so the input schema fully documents all parameters and nested objects. The description adds no parameter-level details beyond naming the calculation areas, so baseline 3 is appropriate.

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 the tool as calculating water chemistry conversions, CO2, salinity, and water-mix estimates, using a specific verb and resource list. This distinguishes it from sibling calculators like calculate_tank_volume or convert_units.

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 listed capabilities imply when the tool is relevant, but the description provides no explicit guidance on when to use this calculator versus sibling calculate_* tools, nor does it caution about selecting one of the multiple input modes. It is minimally viable but not proactive.

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

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

Annotations already provide readOnlyHint=true and destructiveHint=false, and the description's 'Calculate' is consistent. It adds the behavioral constraint that the plan must be non-persistent, which is useful for selection. No contradiction with annotations.

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

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

The description is a single, front-loaded sentence with no fluff or redundancy. Every word contributes to the purpose.

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

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

Given the rich input schema with full descriptions, the presence of an output schema, and annotations declaring safety, the description is mostly sufficient. It could optionally mention how volume_liters factors into totals, but the schema already explains that parameter. The description covers the core intent well.

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 100%, so all parameters (volume_liters, items, targets, measurements, etc.) are already well-documented in the schema. The description itself adds no parameter-specific meaning, hence the baseline score of 3.

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 ('Calculate') with a clear resource ('weekly fertilizer totals') and a qualifier ('non-persistent dosing plan') that distinguishes it from sibling tools like calculate_fertilizer_dose or generate_fertilization_plan. It clearly conveys what the tool does.

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 clear context: it is for a supplied non-persistent dosing plan, which tells the agent when to use it. However, it does not explicitly name alternatives or state when not to use it, so it falls short of a 5.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the description only needs to add context beyond these. It adds 'basic' and 'using Atlarium data', which qualifies scope and data source, but does not elaborate on what 'basic' means or any response behavior.

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

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

The description is a single, front-loaded sentence with no filler. It concisely states the action, object, and data source without wasting words.

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

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

The tool has seven parameters and an output schema, and annotations cover safety. The description is adequate but minimal; it doesn't explain how to choose this over sibling tools and the term 'basic compatibility' is vague. However, the output schema likely covers return value details, so this is not a critical gap.

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 100%, with all seven parameters individually described in the input schema. The tool description itself adds no additional parameter semantics, but per the rubric baseline 3 is appropriate when the schema already does the heavy lifting.

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

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

The description uses the verb 'Check' and specifies the resource 'compatibility information between habitat species', along with the data source 'Atlarium data'. This clearly distinguishes it from sibling tools like get_fish_profile or suggest_species_for_tank, though it 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?

The description implies a use case—checking compatibility between species—but provides no explicit when-to-use guidance, alternatives, or exclusions. Given the large sibling set that includes related tools like suggest_species_for_tank, the lack of usage context leaves some ambiguity.

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

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

Annotations already indicate read-only, idempotent, non-destructive behavior. The description adds the aquarium-relevant scope but omits mention of temperature_delta support and the ability to handle multiple conversion types in a single call. No contradiction with annotations.

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

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

The description is a single 9-word sentence that immediately states the verb and scope. No redundant information or filler.

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

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

The description omits the temperature_delta input category, which is a fifth parameter in the schema. While the schema and output schema are rich, the description fails to fully enumerate the tool's capabilities, creating a mismatch between the stated categories and actual parameters. This prevents a higher score.

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 100% description coverage with detailed enums and constraints for each unit category. The tool description merely lists categories (temperature, length, weight, volume) without adding parameter-specific semantics beyond what the schema provides. Baseline 3 is appropriate as schema carries the weight.

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 converts aquarium-relevant units across four categories (temperature, length, weight, volume), using a specific verb and resource. It distinguishes itself from sibling calculation tools, which focus on specific aquarium computations rather than generic unit conversion.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not mention exclusions, use cases, or relationships to sibling calculation tools. The agent must infer that conversion is a prerequisite or separate operation.

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

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

Annotations already declare readOnlyHint and idempotentHint, and the description adds 'non-persistent' and 'advisory', which clarifies that no stored changes occur and the output is consultative. This supplements the annotation without contradiction, though more detail on data validation or error behavior would be welcome.

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, dense sentence that packs the core purpose ('generate'), scope ('advisory non-persistent'), and data source ('public Atlarium catalog') without any wasted words. Every term contributes to understanding the tool's behavior.

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

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

Given the high complexity (nested objects, 6 params, output schema present), the description successfully conveys the essential function and safety profile. The output schema presumably documents return values, so the description need not repeat those, but a brief note on when to provide items vs targets vs measurements would improve 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?

Input schema covers all 6 parameters with 100% description coverage, so the baseline of 3 applies. The description adds minimal parameter-specific meaning beyond stating the data source (public Atlarium catalog), which hints that product_name and brand_name should reference catalog entries but does not explain parameter interactions like how targets and measurements are used.

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 generates an advisory, non-persistent fertilization plan using public Atlarium catalog data. This distinguishes it from sibling tools like calculate_fertilizer_dose (single dose) and get_fertilization_regime (retrieve existing), making the purpose specific 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?

The description provides no explicit guidance on when to use this tool versus alternatives. Sibling tools such as calculate_nutrient_gaps or calculate_weekly_dose_totals serve related purposes, but no differentiation or exclusion criteria are mentioned, leaving the selection decision 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?

Annotations already declare readOnlyHint and idempotentHint, so the agent knows it's a safe read operation. The description adds that the profile is 'public' and 'structured', providing useful context about access and return shape, but no further behavioral details such as language fallback or error behavior.

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

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

The description is a single, front-loaded sentence that immediately states the resource and action. It contains no filler or redundant information, making it highly concise.

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

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

Given the low complexity, presence of an output schema, and full parameter coverage, the description is largely complete. However, it lacks a pointer to search_algae for discovering slugs, leaving a minor discovery gap for an agent.

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 fully describes both parameters (slug pattern and language enum), so the description does not need to repeat them. It adds no additional parameter meaning, but the baseline 3 applies given 100% schema coverage.

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

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

The description uses the specific verb 'Get' with resource 'structured public algae diagnostic profile', clearly stating the tool's function. It differentiates from siblings like search_algae by indicating a single diagnostic profile, though it does not explicitly mention retrieval by slug.

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. It does not mention that search_algae should be used for discovering profiles by query, 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?

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior. The description adds useful context by noting the profile is 'public' and 'structured', implying safe public access and a defined response format. This goes slightly beyond the annotations without contradicting them.

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, compact sentence that front-loads the core action and resource. Every word contributes meaning, with no filler or redundancy.

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

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

For a simple getter, the description covers the basic retrieval function, but it omits any mention of how to obtain a slug (e.g., via search_diseases) and does not describe edge cases like missing slugs. The output schema and annotations compensate for some gaps, but a pointer to the search tool would improve completeness.

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

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

Schema description coverage is 100%, with clear descriptions for both 'slug' and 'language'. The tool description itself adds no parameter-specific meaning, so the baseline of 3 applies per the rubric.

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

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

The description clearly states the tool's function: 'Get a structured public aquatic disease profile.' The verb 'Get' and resource 'disease profile' are specific, and the resource is unique among sibling get_* tools. It lacks an explicit contrast with search_diseases, but the 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 guidance on when to use this tool versus alternatives such as search_diseases or other get_* profile tools. It does not mention prerequisites (e.g., how to obtain a valid slug) or when a profile retrieval is appropriate.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds 'public' (no auth required) and 'structured' (return format), but nothing about errors, missing slugs, or other behavioral nuances. No contradiction.

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 verb and resource. No wasted words or redundant information.

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

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

For a simple read-only getter with full annotations and an output schema, the description is sufficient. It could optionally mention the language parameter, but the schema covers that. No 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 100%, with both slug and language having clear descriptions. The description adds no parameter-specific semantic value, so baseline 3 applies.

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 'Get a structured public equipment product profile.' The verb 'Get' plus the specific resource 'equipment product profile' distinguishes it from sibling tools like get_fish_profile or get_product_profile.

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. For example, it does not mention using search_equipment to find a slug or that this is the canonical way to fetch equipment profiles.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds that the regime is 'public' and 'structured', which implies no auth and a well-defined return shape, but it does not disclose additional behaviors like pagination, rate limits, or response format details. This is acceptable but minimal, matching the calibration baseline for annotation-backed descriptions.

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, six words, with no filler. It is front-loaded with the action and resource. It earns its place by stating the core purpose without redundancy, making it an example of concise writing.

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

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

The tool is simple (2 params, output schema provided, annotations cover safety), so the description needs less. However, the complete absence of usage guidelines and alternative hints makes it less complete than it could be. The schema and output schema compensate for much, but the missing guidance on when to use this vs. search_fertilization_regimes is a clear gap, keeping it at a baseline 'minimum viable' score.

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 100% coverage: both 'slug' and 'language' have descriptions ('Single safe public Atlarium slug without path separators.' and 'Optional preferred response language: it, en or es.'). The description adds no further parameter context, so the baseline of 3 applies since the schema handles the parameter 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 'Get a structured public fertilization regime' clearly identifies the verb ('get') and resource ('fertilization regime'), with scope indicated by 'public'. It is not a tautology and is more specific than a generic 'Process', but it does not explicitly distinguish itself from the sibling 'search_fertilization_regimes' tool, merely hinting at it through the word 'public' and the schema's slug parameter.

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

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

The description gives no guidance on when to use this tool versus alternatives such as 'search_fertilization_regimes' or 'generate_fertilization_plan'. It does not state that this is for fetching a specific known slug, nor does it mention when to use the search tool instead. There is no when-to-use or when-not-to-use information.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds useful context about the resource being 'public' and the result being 'structured,' but it does not disclose error behavior, language handling, or other behavioral nuances beyond the annotations.

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

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

The description is a single, concise sentence with no wasted words. It front-loads the core action and resource, making it easy to parse at a glance.

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 simple get-by-slug nature, the presence of an output schema, and strong annotations, the description is largely sufficient. It covers the public access aspect and the structured response, though it could briefly mention the language parameter or that it retrieves by slug.

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 100%, with both 'slug' and 'language' having descriptive text. The description itself does not add parameter-level meaning, so it does not exceed the baseline for well-documented schemas.

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 ('Get') and resource ('fertilizer product profile'), and the qualifier 'public' distinguishes it from search or calculation tools. However, it does not explicitly differentiate from the closely named sibling get_product_profile, which could cause ambiguity.

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

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

The description provides no guidance on when to use this tool versus alternatives like search_fertilizers or get_product_profile. There is no mention of prerequisites, use cases, or exclusions, leaving the agent without sufficient context for selection.

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

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

Annotations already declare read-only, idempotent, and non-destructive behavior. The description adds that the result is 'structured' and sourced from the Atlarium database, but it does not discuss any additional behavioral nuances such as response format or error cases, which is acceptable given the strong annotation coverage.

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 verb 'Get' and immediately defines the resource. It is efficient and contains no filler, earning a perfect score.

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

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

Given the presence of an output schema, comprehensive parameter schemas, and robust annotations, the description is nearly complete for a simple get-by-slug tool. However, it lacks explicit differentiation from the search_fish sibling, which is a minor gap.

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 100%, with clear descriptions for both 'slug' and 'language'. The tool description adds no extra parameter detail, so it relies on the schema, which suffices for the baseline score of 3.

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 retrieves a structured fish or aquatic animal profile from a specific database. It distinguishes from sibling profile tools by specifying the subject (fish/aquatic animal), though it doesn't mention the required 'slug' parameter, which is left to the schema.

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

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

No guidance is provided on when to use this tool versus alternatives like search_fish or other get_* profile tools. The description only states what it does, leaving the agent to infer usage context from the schema and 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds the word 'public', implying no authentication is needed, and 'structured' hints at response format. However, no additional behavioral traits such as error handling or pagination are disclosed.

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 (6 words) that is front-loaded with the verb and object. Every word adds meaning, with no redundant or placeholder text.

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 an output schema and rich annotations, the description is adequate but incomplete. It lacks essential context about when to use get_guide versus search_guides or other get_* tools, which is a clear gap given the large sibling list. The description does not explain the significance of 'public' or how this tool fits into a workflow.

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 100% with both 'slug' and 'language' already documented. The description adds no parameter-specific detail beyond what the schema provides, so it meets the baseline but does not enhance parameter understanding.

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 ('Get') and identifies the resource ('structured public Atlarium guide'), making it clear this tool retrieves a guide. However, it does not explicitly distinguish this from sibling tools like search_guides, so it lacks sibling 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 use this tool versus alternatives. With 38 sibling tools including search_guides and various get_* profiles, the description provides no context for selection, leaving the agent without usage direction.

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

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

The annotations already declare readOnlyHint, idempotentHint, and destructiveHint as false, covering the safety profile. The description adds 'structured' and 'public' context, signaling deterministic output and no special access, but offers no deeper behavioral detail like rate limits or auth requirements. There is no contradiction with annotations.

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

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

The description is a single front-loaded sentence with no filler or redundancy. It communicates the core function immediately and is appropriately sized for a simple getter 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 simple get-by-slug tool, the combination of a clear input schema, output schema, and strong annotations makes the description nearly sufficient. The only notable gap is the lack of guidance on selecting this tool over search_medicines or other profile getters, but that is more of a usage-guideline concern than a structural incompleteness.

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 100% and both parameters (slug and language) have clear descriptions in the input schema. The tool description adds no parameter-specific meaning, so it does not improve on schema semantics, but the full schema coverage justifies the baseline score of 3.

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 'Get' and clearly identifies the resource as a 'public aquarium medicine profile', which distinguishes it from other medicine-related tools by resource type. However, it does not explicitly contrast it with sibling tools like search_medicines or other get_*_profile tools, so it falls short of full sibling differentiation.

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

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

No usage guidance is provided. The description does not state when to use this tool versus search_medicines or other profile getters, nor does it mention any prerequisites such as needing a slug from a search step. This leaves the agent to infer the appropriate use case from the schema and 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?

Annotations already declare readOnly, idempotent, and non-destructive behavior. The description adds 'structured' and 'public', which hint at response format and accessibility, but it does not disclose behavior on missing slugs or language fallback. No contradiction.

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 contributes to the core purpose.

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

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

For a simple get-by-slug tool with an output schema and annotations, the description is adequate. It lacks guidance on how to discover slugs (e.g., via search), but given the schema and annotations, it is reasonably 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 coverage is 100%, with both slug and language having clear descriptions. The description adds no meaning beyond the schema, so the baseline of 3 applies.

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 returns a structured profile for aquatic plant problems or deficiencies. The verb 'Get' and specific resource distinguish it from sibling tools like get_plant_profile (general plant) and search_plant_problems (search, not get).

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 guidance on when to use this tool versus alternatives like search_plant_problems, nor does it mention prerequisites or exclusions. The word 'public' hints at accessibility but offers no explicit context for tool selection.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds no behavioral context beyond the word 'structured', which is redundant given the output schema. No additional details about auth, rate limits, or response characteristics are provided.

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

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

The description is a single, front-loaded sentence with no filler or repetition. It is appropriately sized for a simple getter tool and wastes no words.

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

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

The tool is simple, and the schema and annotations cover parameters and safety. However, the description omits guidance on when to use this tool versus search_plants or how it relates to the other profile getters, leaving some contextual gap for an agent deciding among 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?

Schema coverage is 100%: both 'slug' and 'language' have descriptive details in the input schema (slug format, allowed languages). The description adds no parameter information, so the baseline score of 3 applies.

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 'get' and identifies the resource as an 'aquatic plant profile', which clearly distinguishes it from sibling profile tools like get_fish_profile and get_algae_profile. However, it does not explicitly mention the slug parameter or contrast with search_plants, so sibling differentiation is implicit rather than explicit.

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 guidance on when to use this tool versus alternatives such as search_plants or other profile getters. It is a single phrase with no context on prerequisites, required inputs, or typical invocation sequences.

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

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

The annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, which conveys the safety profile. The description adds 'public' (implying no authentication needed) and 'structured' (though the output schema confirms structure). This is minimal context, and no rate limits or pagination behavior are disclosed, so a 3 is appropriate given the annotation coverage.

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. Every word carries meaning, making it highly concise and well-structured.

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

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

The tool has a rich input schema (2 parameters with descriptions), a full output schema, and comprehensive annotations. The description, while short, conveys the core purpose and public nature. The only gap is not defining what 'habitat product' means or distinguishing it from related profile tools, but the structured information covers most operational needs.

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 100%, and both parameters (slug and language) have detailed descriptions in the schema. The description itself adds no parameter-specific meaning beyond the schema, so the baseline score of 3 applies.

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 clear verb 'Get' and identifies the resource as a 'structured public habitat product profile.' It clearly indicates the tool retrieves a product profile, but it does not explicitly differentiate it from sibling tools like get_fish_profile or search_products, which would merit a 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?

Usage is implied: the description conveys that you use this tool when you need a structured public product profile for a specific slug. However, it provides no explicit when-to-use guidance, alternatives, or exclusions, so it only meets the minimum for implied usage.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is clear. The description adds minimal behavioral context beyond 'recommended', which hints at the nature of the values. No contradiction with annotations.

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

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

The description is a single, front-loaded sentence that gets straight to the point with zero wasted words.

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

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

For a simple read tool with a clear schema and provided output schema, the description is adequate. It lacks explicit mention of alternatives, but the tool's simplicity and the output schema compensate for minimal description.

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 100%, with each parameter described. The description does not add extra meaning beyond the schema, but the schema sufficiently documents slug, type, and language.

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 'Get' with a clear resource 'recommended water parameters' and target 'aquatic species or plant'. It distinguishes from sibling tools like get_fish_profile or get_plant_profile by focusing solely on water parameters.

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 purpose implies when to use the tool (when needing water parameters), but there is no explicit guidance about alternatives or exclusions. With many sibling tools, more explicit direction would help, but the intent is understandable.

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

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

The description adds the qualifier 'public', clarifying that only public brands are returned, which goes beyond the annotations' readOnlyHint and idempotentHint. However, it does not disclose other behavioral traits like pagination or sorting, but the output schema likely covers return structure. The description is consistent with annotations.

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

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

The description is a single, concise sentence that directly states the purpose without wasted words. It is front-loaded with the verb and resource, and every word earns its place.

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

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

For a simple listing tool with two optional parameters and an output schema, the description is adequate. It tells the agent the tool's purpose and scope ('public'). However, it lacks any guidance on filtering behavior or relationship to sibling listing tools, so it is 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?

The input schema descriptions cover 100% of the parameters (query and language), so the baseline is 3. The description itself adds no additional parameter-related details beyond what the schema already provides.

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

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

The description clearly states the tool's function: 'List public Atlarium product brands.' The verb 'List' and resource 'public Atlarium product brands' are specific and distinguish it from sibling tools like list_product_categories and search_products.

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 guidance on when to use this tool versus alternatives. There is no mention of use cases, exclusions, or relationships to sibling tools such as list_product_categories or search_products.

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

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

Annotations already declare read-only, idempotent, and non-destructive behavior, while the description adds the 'public' scope, suggesting no user-specific data. It does not mention pagination or default behavior when no type is provided, but the simple nature of the tool and annotation coverage keep this adequate.

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, direct sentence that immediately states the action and scope with no redundant words or filler.

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

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

Given the tool's low complexity, existing output schema, and comprehensive annotations, the description covers all essential aspects—purpose, scope, and domain. No additional context is needed.

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?

Both parameters are fully described in the schema with enums and descriptions, providing 100% coverage. The description's mention of 'equipment and fertilizers' only echoes the type enum without adding new meaning, so it meets the baseline but doesn't elevate it.

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

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

The description uses the specific verb 'List' with the resource 'product categories' and scopes it to 'public Atlarium' equipment and fertilizers, distinguishing it from sibling tools like list_product_brands and get_product_profile.

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

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

The description clearly sets the context for listing product categories, implying a browsing or catalog use case. However, it does not explicitly reference alternatives or state when not to use this tool, so it lacks explicit exclusion 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?

Annotations already declare the tool read-only, idempotent, and non-destructive, so the safety bar is covered. The description adds that it returns 'public' records (not private) and 'likely' matches (ranked, not guaranteed), which provides some extra behavioral context beyond the annotations. This is modest added value, so a 3 is appropriate.

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

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

The description is a single, front-loaded sentence with no redundant or filler words. It clearly states the action and the object. Every word earns its place, making it a model of 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?

While the schema and annotations cover parameters and safety, the description provides minimal guidance on how to effectively use the tool, such as combining symptom query with filters (type, difficulty, water_type) or what 'likely' results mean. For a tool with 7 parameters and an output schema, a bit more context about the matching behavior and result interpretation would be expected, but the existing information is not inadequate.

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 100%, so all seven parameters are already explained in the input schema. The description's mention of 'symptom query' aligns with the 'query' parameter but does not add meaning beyond what the schema provides. Baseline 3 is correct because the schema carries the full semantic load.

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

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

The description uses the verb 'Find' and specifies the exact resource ('likely public algae, disease, plant problem and medicine profiles') and the input type ('symptom query'). This clearly distinguishes it from sibling tools like search_algae or search_diseases, which target a single profile type with direct name searches.

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 use when the user has a symptom query and wants matches across multiple diagnostic profile types. However, it does not explicitly state when to prefer this over the many specific search_* tools or provide exclusions/alternatives. The usage context is implied but not directly contrasted with sibling tools.

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

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

Annotations already declare readOnly, idempotent, non-destructive, so safety is covered. The description adds useful scope ('public') and content semantics (profiles include symptoms, causes, treatment guidance), enhancing behavioral understanding without contradicting annotations.

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

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

A single, front-loaded sentence with no filler. Every phrase adds value: scope ('public'), domain ('algae diagnostic profiles'), and content ('symptoms, causes and treatment guidance').

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 rich input schema (7 documented optional filters), output schema, and strong annotations, the description provides sufficient context. It captures the tool's purpose and scope; no additional behavioral or return-value explanation is necessary.

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?

All 7 parameters are fully described in the schema (100% coverage), so the burden on the description is low. The description additionally clarifies what query text matches ('symptoms, causes and treatment guidance'), adding meaning beyond the generic 'match public Atlarium records' schema text.

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

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

Description uses specific verb 'Search' and identifies the resource as 'public algae diagnostic profiles', mentioning content (symptoms, causes, treatment guidance). This clearly distinguishes it from sibling search tools like search_diseases and get_algae_profile.

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 establishes clear context: use this to search public algae diagnostic profiles, implying it is the tool for finding algae diagnostics rather than retrieving a specific item (get_algae_profile). It doesn't explicitly name alternatives or exclusions, but the public-scope and algae-specific wording provide enough 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is clear. The description adds value by noting the 'public' scope and 'advisory' nature of the information, which are useful contextual additions. However, it does not elaborate on authentication needs, rate limits, or other behavioral aspects beyond the annotations.

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

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

The description is a single, front-loaded sentence: 'Search public aquatic disease diagnostic profiles and advisory treatment information.' It contains no redundant words and every phrase contributes to understanding the tool's purpose, making it highly concise and well-structured.

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

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

With a complete input schema, an output schema, and strong annotations, the description covers the essential purpose and adds the 'public' and 'advisory' context. It is brief but sufficient for a search tool; the only notable gap is the lack of comparison with alternative search tools, which is more a usage-guideline issue than a completeness one.

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 100% for all 7 parameters, so each parameter is already documented in the input schema. The description does not add any parameter-specific semantics beyond the general mention of disease profiles and advisory treatment information, which is consistent with the baseline for full schema coverage.

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

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

The description uses the specific verb 'Search' and clearly identifies the resource as 'public aquatic disease diagnostic profiles and advisory treatment information.' This distinguishes it from sibling tools like get_disease_profile (single profile retrieval) and match_diagnostic_profiles (matching profiles), making the purpose unmistakable.

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 guidance on when to use this tool versus alternatives. It does not mention exclusions or suggest related tools such as get_disease_profile or match_diagnostic_profiles, leaving the agent to infer the appropriate context without explicit direction.

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

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

Annotations already provide readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is known. The description adds the 'public' scope and 'aquarium and habitat' domain, but does not describe behavior like pagination or return characteristics beyond what annotations and schema provide.

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 (8 words) that is front-loaded with the action and resource. It contains no fluff or repetition.

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

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

For a simple read-only search tool with seven well-documented parameters, strong annotations, and an output schema, the description is complete enough. It clearly scopes the search to public equipment products without needing 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 100%, with every parameter having a clear description. The tool description does not add extra meaning beyond the schema, so the baseline of 3 is appropriate.

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 ('Search') and clearly identifies the resource ('public aquarium and habitat equipment products'). This distinguishes it from sibling search tools like search_products and search_fertilizers by narrowing the scope to equipment.

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 equipment searches but does not explicitly state when to use this tool over alternatives such as search_products. It names no exclusions or alternative tools, leaving the comparison to the agent.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so safety is covered. The description adds the 'public' scoping constraint, which provides useful behavioral context, but does not disclose pagination behavior or response structure 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?

A single sentence conveys the core purpose without waste. It is front-loaded and immediately understandable.

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

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

The tool is a simple search with comprehensive schema, annotations, and an output schema. The description covers the essential purpose and public scoping; no additional behavioral or return details are necessary.

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 100%, so all five parameters are already documented. The description adds no extra semantics about query syntax, topic filtering, or language options beyond what the schema provides.

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 'Search' and resource 'public fertilization regimes and dosing philosophies', clearly distinguishing it from sibling tools like get_fertilization_regime and search_fertilizers. It states both the action and scope precisely.

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 searching public regimes but provides no explicit alternatives or exclusions. Sibling tools such as get_fertilization_regime are not mentioned, so guidance on when to choose this over retrieving a specific regime is missing.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the agent knows this is a safe, read-only operation. The description adds the 'public' scope constraint, which is useful context. However, it does not disclose other behavioral details like pagination defaults or language fallback, so it provides some but not rich context beyond annotations.

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

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

The description is a single sentence with no filler, front-loaded with the action verb 'Search'. It efficiently conveys the tool's purpose without redundancy, earning a top score for conciseness and 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 search tool with 7 optional parameters, an output schema, and strong annotations, the description is fairly complete. It clearly defines the search scope ('public aquarium fertilizer products and nutrient profiles') and the schema handles parameter details. It could optionally mention pagination or language options, but those are already documented in the schema, so the description is adequate without 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 100%, with each of the 7 parameters having a clear description, so the baseline is 3. The description does not add parameter-level details, but the phrase 'nutrient profiles' suggests the query field matches product and nutrient information, which aligns with the schema. No additional semantics needed beyond the thorough schema.

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

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

The description uses a specific verb ('Search') and resource ('public aquarium fertilizer products and nutrient profiles'), clearly distinguishing it from sibling tools like search_products and search_fertilization_regimes. The inclusion of 'public' and 'nutrient profiles' further narrows the scope, making the tool's purpose immediately clear.

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

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

The description does not explicitly state when to use this tool vs alternatives, nor does it mention exclusions. However, the focus on 'public aquarium fertilizer products and nutrient profiles' implies a specific use case, and the 'public' qualifier hints at a distinction from private/paid products. Still, with many sibling search tools, explicit guidance would be more helpful.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is clear. However, the description adds no additional behavioral context such as return format, pagination defaults, or filtering scope beyond what the schema states. Nothing contradicts the annotations, but no extra value is provided.

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 redundant wording. It front-loads the action and resource, earning every word it uses.

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 search tool with 16 parameters but a rich schema and output schema, the one-line description is minimally viable. It states the core purpose but lacks usage context or behavioral details, which would help an agent select it among many sibling search tools. Structured data covers a lot, but the description alone leaves gaps in when/how to use it.

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

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

The input schema has 100% description coverage for all 16 parameters, each with clear descriptions. The tool description itself adds no parameter-level information, so the baseline of 3 is appropriate given that the schema fully documents the 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 uses a specific verb ('Search') and clearly identifies the resource ('fish and aquatic animal profiles') within a defined context ('Atlarium habitat database'). This distinguishes it from sibling search tools like search_plants or search_diseases.

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 guidance on when to use this tool versus alternatives, nor does it mention any exclusions or prerequisites. Siblings like get_fish_profile or search_plants exist, but no comparison or selection criteria are given.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the agent knows this is a safe read operation. The description adds no behavioral context beyond the act of searching, but it does not contradict the annotations. Given the comprehensive annotation coverage, a neutral score is appropriate.

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

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

The description is a single, front-loaded sentence with no redundant words. It communicates the core purpose efficiently and wastes no space.

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 schema fully documents all parameters, an output schema exists, and annotations cover the safety profile. The description identifies the resource type clearly. The only gap is usage differentiation, which is already scored separately, so overall the context is sufficient for a simple search tool.

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

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

All five parameters have full descriptions in the schema, including constraints like maxLength, maximum, and enum values. The description adds no additional meaning or context beyond what the schema already provides, so the baseline of 3 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 verb 'Search' with a specific resource ('Atlarium habitat guides and educational content'), which clearly distinguishes it from sibling tools that search species, products, or other data. However, 'educational content' is somewhat broad and could overlap with guides, so it is not perfectly scoped.

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 other search tools or get_guide. There are no exclusions, alternatives, or contextual hints about whether this is for broad discovery or specific guide lookup.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds the 'public' qualifier, indicating the search only covers public profiles, but does not disclose pagination or language behavior (though these are in 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 a single, direct sentence with no filler. It immediately states the action and target, earning a high score for 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 the full schema, output schema, and strong annotations, the description provides adequate context for a simple search tool. However, it lacks any guidance on how this search relates to sibling search tools, which is a minor gap in 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?

The schema has 100% parameter description coverage, so each of the 7 parameters is already documented. The description adds no additional parameter context, but the baseline of 3 applies because the schema does the heavy lifting.

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 ('Search') and resource ('public aquarium medicine and treatment product profiles'). This distinguishes it from sibling search tools like search_products or search_diseases, which target different record types.

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 guidance on when to use this tool versus sibling search tools. It does not mention alternatives or exclusions, leaving the agent to infer from the resource name alone.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, so the safety profile is covered. The description adds the 'public' scope, which is useful behavioral context, but it does not disclose details like matching behavior or pagination. This matches the rubric's baseline for annotation-supported descriptions.

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 effectively communicates the tool's purpose in just nine words, earning top marks for 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 the presence of an output schema and fully documented parameters, the description is sufficient for an agent to understand the tool's role. It could be slightly more complete by mentioning the query-based nature, but the schema compensates. Overall it is adequate and well-scoped.

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 provides 100% coverage of all 7 parameters with descriptions, so the description adds no additional parameter semantics. The baseline of 3 applies because the schema carries the full explanatory burden.

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 searches 'public aquatic plant deficiency, pest and environmental problem profiles', using a specific verb and resource that distinguishes it from sibling tools like search_algae and search_diseases. It precisely conveys what the tool does.

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

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

The description gives clear context by specifying 'public' profiles and the problem categories, implying when this search tool is appropriate. However, it does not explicitly mention alternatives or when not to use it, such as when retrieving a specific profile with get_plant_problem_profile.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. However, the description adds no behavioral context beyond the verb 'search'—it does not disclose pagination, filtering semantics, or any limitations. It is consistent with annotations but contributes no extra transparency.

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 worded sentence with no padding or redundancy. It front-loads the essential action and object, making it instantly 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 (9 optional parameters, output schema exists), the description is minimally adequate. The schema and output schema fill in the gaps for parameter semantics and return structure. However, the description does not convey the overall search scope (e.g., what fields are matched), which could help an agent decide if this tool fits the task. It is not incomplete enough to be unusable.

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 100% coverage—every parameter has a descriptive comment. The tool description itself does not add meaning to the parameters; it only names the resource. This matches the baseline of 3 when schema coverage is high.

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

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

The description clearly states the tool's function: 'Search aquatic plants in the Atlarium database.' It specifies an action (search), a resource (aquatic plants), and a context (Atlarium database). This distinguishes it from sibling search tools like search_fish or search_algae, which target different domains.

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 guidance on when to use this tool versus alternatives. It does not mention exclusions, prerequisites, or preferred scenarios. The sibling list implies a family of search tools, but the description does not explicitly differentiate when search_plants 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the description adds only the scope of 'public habitat products' and 'Atlarium database.' This is useful but minimal beyond the annotations; no extra behavioral traits such as pagination behavior or access constraints are disclosed.

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 ('Search public habitat products in the Atlarium database.') that is front-loaded with the action and resource. Every word serves a purpose, and there is no redundancy or filler.

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

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

With 7 optional parameters, a full output schema, and annotations, the description is acceptable but minimal. It does not mention filtering capabilities, pagination, or language options, though these are present in the schema. The lack of usage guidance and alternative tool references leaves some context 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?

The input schema has 100% description coverage for all seven parameters, so the schema carries the burden of parameter meaning. The description adds no additional parameter semantics, only mentioning 'public habitat products' which could imply filters but does not explicitly link to any schema properties.

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 searches for products ('Search public habitat products in the Atlarium database'), using a specific verb and resource. It distinguishes from sibling search tools by focusing on 'products' rather than algae, diseases, or equipment, but it does not explicitly contrast with sibling tools like get_product_profile.

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 (e.g., get_product_profile, list_product_brands, or other search_* tools). There is no mention of preferred scenarios or exclusions, leaving the agent to infer usage from the name and schema alone.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true, so the safety profile is covered. The description adds that the plan includes species, plants, products, warnings, motivations, and guides, which gives useful behavioral context about the scope of the result. This is helpful, though not rich enough to exceed a baseline given the strong annotations.

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

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

The description is a single sentence, 17 words, with the verb and object front-loaded. Every phrase adds value ('complete', 'public', listing of plan components). No redundant information.

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

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

Despite having 15 parameters and an output schema, the description sufficiently conveys the tool's core purpose and result composition. The output schema likely covers the return structure. The description is brief but complete for the agent to decide invocation, though it could mention how parameters influence the plan.

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 100% and all parameters are documented in the schema. The description does not add any extra meaning to any specific parameter, but the schema already handles this. Per the baseline rule for high coverage, a 3 is appropriate.

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 it 'Suggest a complete public habitat plan with species, plants, products, warnings, motivations and related guides.' This uses a specific verb ('suggest') and resource ('habitat plan') while enumerating the plan's components, clearly differentiating it from the sibling 'suggest_species_for_tank' which focuses only on species.

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

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

The description clearly implies when to use this tool: when a complete habitat plan is needed rather than a single-species suggestion. However, it does not explicitly state exclusions or name alternatives, so it misses the 'when-not / alternatives' bar for a 5.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is known. The description adds context by specifying that suggestions are 'based on tank size and water parameters,' which communicates scope. However, it does not reveal additional behavior such as ranking, default behavior when parameters are missing, or output size.

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 12-word sentence, extremely efficient, and front-loaded with the verb and object. Every word contributes to stating the core purpose with zero waste. This meets the standard of 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?

With good annotations, a fully described schema, and an output schema present, the description only needs to add context for when to use the tool. It explains the core inputs but does not distinguish from closely related siblings like 'suggest_habitat_for_tank' or 'check_species_compatibility', leaving the context only partially 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 100%, so every parameter is already documented with descriptions. The description's mention of 'tank size and water parameters' aligns with the schema but adds no new details beyond it. Baseline of 3 is appropriate because the schema carries the burden.

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

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

The description clearly states the tool's function: 'Suggest compatible aquatic species based on tank size and water parameters.' It uses a specific verb ('suggest') and resource ('species') and differentiates from sibling tools like 'suggest_habitat_for_tank' (habitats) and 'check_species_compatibility' (checking existing species).

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. Unlike the high-calibration example that names a sibling tool for alternative scenarios, this description does not mention 'check_species_compatibility' or 'suggest_habitat_for_tank' as alternatives, nor any conditions for use.

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