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=true, idempotentHint=true, destructiveHint=false, so the agent knows this is a safe, non-destructive read operation. The description adds that the profile is 'public' and 'structured', and that the slug must be exact, which provides minor additional context. No contradiction with annotations, but no deep behavioral details beyond what annotations 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 sentence of 15 words, front-loaded with the verb 'Get'. It contains no unnecessary words or repetition, and every part of the sentence contributes to understanding the tool's purpose and usage.

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 present (context signal), the description does not need to explain return values. The tool is simple (2 params, 1 required). The description covers the purpose, the prerequisite (slug from search_algae), and the nature of the profile ('public', 'structured'). It is largely complete, though it could briefly mention what the profile contains (e.g., algae identification details) but that is handled by the output schema.

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

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

Schema coverage is 100% with both parameters having descriptions. The description reinforces that the slug must be 'exact' and from 'search_algae', adding slight extra context. Since the schema already describes the parameters well, the description does not add significant new meaning, earning a 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 verb 'Get' and the resource 'structured public algae diagnostic profile', and distinguishes it from sibling tools by specifying the slug must come from 'search_algae'. This immediately informs the agent of the tool's exact function and how it relates to other tools.

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

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

The description explicitly says to use the slug returned by 'search_algae', providing a clear prerequisite and usage context. While it does not list alternative tools or when not to use it, the guidance is sufficient for an agent to determine the correct invocation sequence among many sibling get_* 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 readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is clear. The description adds that the profile is 'public' and 'structured', which adds minor context. 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, front-loaded sentence with no unnecessary words. It conveys purpose and prerequisite efficiently. 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?

Given that an output schema exists (indicated by context signals), the description does not need to detail return values. It covers the resource type (disease profile), domain (aquatic), and the required input source (search_diseases). A minor addition about what the structured profile includes (e.g., symptoms, treatments) could be helpful but is not essential.

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 schema already documents both parameters (slug and language). The description mentions 'exact slug' but does not add new semantic detail beyond what's in the schema. Baseline score 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 clearly states the tool retrieves a structured aquatic disease profile using a slug from search_diseases. This specifies the resource (disease profile), action (get), and domain (aquatic disease), effectively distinguishing it from sibling get_* tools for other entity 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 explicitly states the prerequisite: use the exact slug returned by search_diseases. This provides clear context on when to use this tool (after searching for diseases). It does not explicitly list when not to use it or mention alternatives, but the prerequisite is well-defined.

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 declare readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=false, which accurately characterize this as a safe, read-only operation. The description adds useful context that the profile is 'public' (no auth barrier beyond the api key), and specifies the input constraint. No contradictions.

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

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

The description is a single, concise sentence that front-loads the core action and resource, then adds the essential prerequisite constraint. Every word is necessary; no fluff or repeated 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?

Given the low complexity (2 parameters, simple schema, no nested objects), clear annotations, and an output schema that handles return value documentation, this description is adequate. It provides the key context about data source (slug from search) and scope (public profile). Users have enough to invoke the tool correctly.

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

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

Schema description coverage is 100%, so both parameters are well-documented in the schema. The description adds value by explaining the relationship with search_equipment ('returned by') and clarifies the 'language' parameter is optional and its use case ('preferred response language'). This provides meaning beyond the schema's enum listing.

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 specifies the verb ('Get'), the resource ('structured public equipment product profile'), and a unique constraint ('using the exact slug returned by search_equipment'). This differentiates it from sibling tools like search_equipment (which searches) and get_product_profile (which gets a different product type).

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 explicitly states the required input format ('exact slug returned by search_equipment'), implying that the user must first call search_equipment. It does not explicitly list when not to use it or alternative tools, but the sibling context and distinct resource name provide clarity.

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 description adds value by mentioning the result is 'public' and 'structured', implying no authentication and consistent format. No contradictions.

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

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

Single sentence that front-loads the action and resource. No superfluous words. Could be slightly more structured by separating input and output, but it 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?

With an output schema present and a simple read operation, the description adequately explains what the tool does and how to use the slug. The sibling list clarifies the workflow. No missing critical information.

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

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

Schema coverage is 100% and the slug parameter already has a clear description. The description adds context about the slug originating from a sibling search tool, but does not fundamentally extend parameter understanding 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?

Description states a specific verb ('Get') and resource ('structured public fertilization regime'), and clearly links to the sibling tool 'search_fertilization_regimes' via slug. This differentiates it from siblings like `search_fertilization_regimes` and other `get_*` tools.

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

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

Explicitly instructs to use the slug from `search_fertilization_regimes`, providing clear context for when to invoke this tool. Does not explicitly state when not to use it, but the instruction is sufficient given the sibling relationship.

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 the tool as read-only, idempotent, non-destructive, and not open-ended, so the behavioral baseline is well-covered. The description adds minimal behavioral context beyond this, merely stating it retrieves a 'public' profile. Since the annotations carry the burden, a score of 3 is appropriate as the description does not contradict and adds a bit of context (public nature) but no further details.

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

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

The description is a single sentence that perfectly captures the essential purpose and key usage instruction (slug from search_fertilizers) without any wasted words. Every part of the sentence earns its place, making it highly concise and efficiently structured.

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

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

Given the low parameter count (2), high schema coverage (100%), comprehensive annotations (covers safety, idempotency, etc.), and the presence of an output schema, the description adequately covers the tool's role. It provides the critical context about slug origin, which compensates for what the schema doesn't capture. It could be more complete by noting any error handling or default behaviors for the language parameter, but it's sufficiently comprehensive for most use cases.

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%, meaning the schema already fully documents both parameters (slug and language) with their constraints, patterns, and descriptions. The description does not add new parameter meaning beyond referencing the slug's origin from 'search_fertilizers', which provides useful context for selecting the correct value but doesn't enhance semantic understanding of the parameters themselves. Thus, the baseline score of 3 is fitting.

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 public fertilizer product profile' using a specific identifier ('slug'), which is a specific verb+resource combination. It also distinguishes this tool from the sibling 'search_fertilizers' by linking the slug input to that search tool, making its unique purpose and relationship 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 explicitly specifies that the slug must be the exact one returned by 'search_fertilizers', which provides clear guidance on when and how to use this tool. However, it does not mention when not to use it or provide alternative tools for different scenarios (e.g., searching vs. retrieving a profile), leaving some implicit 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 readOnlyHint=true, idempotentHint=true, destructiveHint=false, covering the safety profile. The description adds that the returned data is a 'structured profile' and that the slug must be exact from search_fish, which is useful but not substantial beyond the annotations. No contradiction present.

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

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

A single, front-loaded sentence that immediately states the action and resource, then adds the critical usage context. Every word earns its place—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?

Given the presence of an output schema (context signal: true), the description does not need to detail return values. It adequately covers input source, scope, and the fact that the result is a structured profile. It could optionally mention the language parameter, but that is optional and described in the schema. Complete for its purpose.

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

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

Schema description coverage is 100%, so the schema already documents both parameters well. The description merely reinforces that the slug must come from search_fish, which is already stated in the schema for the slug parameter. It adds no new meaning to the language parameter. 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 states the action ('Get a structured... profile') and the specific resource ('fish or aquatic animal'). It explicitly references the required input source ('exact slug returned by search_fish'), which strongly distinguishes it from sibling profile-retrieval tools like get_algae_profile or get_plant_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 provides clear context by stating the prerequisite (use search_fish first to obtain the slug) and implies the tool is for fetching full details after search. It does not explicitly state when not to use it or name alternatives, but the sibling set makes the intended workflow obvious. Slightly below perfect for lacking explicit exclusions.

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, idempotentHint=true, destructiveHint=false, and openWorldHint=false. The description adds that the guide is 'structured public', which is useful context about data access and format. That additional context justifies a 3, but the heavy lifting is done by 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 that immediately states the core action, resource, and key dependency. Every word is necessary; 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?

For a simple get tool with two well-documented parameters, an output schema, and strong annotation coverage, the description is complete. It covers what the tool does, how to invoke it (using the slug), and the public nature of the data. Minor gaps like error behavior are acceptable given the simplicity.

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

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

Schema description coverage is 100%, so the input schema already fully documents both parameters. The description verbally reinforces the slug's origin and the language's optional nature, but adds no new semantic meaning beyond what the schema provides. 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 uses a specific verb ('Get') and resource ('structured public Atlarium guide'), and explicitly ties the slug to the output of the sibling tool 'search_guides'. This clearly differentiates it from other get_* and search_* tools in the sibling list.

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

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

The description gives a clear condition for use: you must have the exact slug returned by search_guides. This implies the prerequisite step. However, it does not explicitly state when not to use this tool or mention alternative tools for similar tasks.

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, destructiveHint=false, making the safety profile clear. The description adds only that it returns a 'structured public aquarium medicine profile', which is mildly helpful but does not elaborate on errors, rate limits, or response format. With annotations present, this is 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, front-loaded sentence that conveys the core purpose and prerequisite without any waste. 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 2-parameter tool with full annotations and an output schema (not shown but present), the description is sufficient. It explains the key dependency and purpose. Missing a brief note on the return structure, but the output schema covers that.

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 parameters already described in detail (slug: from related search tool; language: optional enum). The main description reaffirms the slug source but adds no new meaning beyond the schema. 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 states the tool gets a structured public aquarium medicine profile using the exact slug from search_medicines. This is a specific verb-resource pair with a clear dependency, distinguishing it from sibling get_* tools.

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

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

The description explicitly states the prerequisite to use the slug returned by search_medicines, guiding the agent to first search then retrieve. It does not explicitly exclude other usage scenarios, but the context of siblings makes it clear this is for medicine profiles only.

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, destructiveHint=false, so the safety profile is fully covered. The description adds the fact that the profile is 'public', implying no authentication is needed, but this is a minor addition. 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 sentence that immediately states the core action and resource, then adds the key usage condition. No redundant words, highly efficient.

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

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

Given the presence of an output schema, annotations, and 100% parameter coverage, the description provides all necessary context: what it does (get profile), what input is required (slug from search), and an optional customization (language). No gaps remain for the agent to infer.

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

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

Schema coverage is 100% and both parameters are well-documented in the schema. The description reinforces the coupling between the slug and search_plant_problems, adding practical semantics beyond the schema's 'related Atlarium search tool' phrasing. This extra context justifies a score above baseline 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 verb 'Get' and the resource 'structured public aquatic plant problem or deficiency profile', and it explicitly links the input slug to the sibling tool 'search_plant_problems', distinguishing it from other get tools like get_algae_profile or get_disease_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 provides explicit guidance on when to use the tool: only after obtaining the exact slug from search_plant_problems. It does not mention when not to use it or list alternatives, but the prerequisite is clearly stated, making it easy for the agent to decide.

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 indicate read-only, idempotent, and non-destructive behavior. The description confirms a safe lookup operation without contradictions, adding clarity about the slug dependency.

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

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

The description is a single sentence that efficiently conveys the core purpose and prerequisite. No extraneous information, perfectly front-loaded.

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

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

Given the existence of an output schema and complete parameter descriptions, the description adequately covers the missing context (slug source). Slightly more could be said about language behavior, but not 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 coverage is 100%, so baseline is 3. The description adds value by referencing the provenance of the slug (from search_plants), and the schema already provides detailed constraints and descriptions for both 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 it retrieves a structured aquatic plant profile using a specific identifier. It distinguishes itself from sibling tools like search_plants by explicitly requiring the slug from that tool.

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

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

The description provides clear guidance to use the slug from search_plants, but does not mention when to use alternatives or when not to use this tool. It implies usage after a search but lacks exclusion criteria.

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 fully covered. The description adds context about the result being 'structured' and 'public', but does not disclose additional behavioral traits (e.g., rate limits, authentication needs) beyond what annotations provide. With strong annotations, this is acceptable.

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 unnecessary words. Every piece of information earns its place: verb, resource, modifier ('structured public'), and the precondition linking to search_products.

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 only two parameters (one required), an output schema (not shown), and comprehensive annotations. The description covers the key behavioral context (precondition, public nature) and parameter semantics for the critical slug field. For a simple lookup tool, this is fully sufficient.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value for the slug parameter by specifying it must come from 'search_products', which is more explicit than the schema's 'related Atlarium search tool'. The language parameter is not mentioned in the description, but the schema already documents its enum values and optionality. Overall, the description enhances understanding of the most critical parameter.

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

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

The description uses a specific verb ('Get') and resource ('structured public habitat product profile'), and distinguishes this tool from siblings like get_fish_profile or get_plant_profile by specifying the resource type and the precondition ('using the exact slug returned by 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 explicitly states when to use this tool: after retrieving a slug from search_products. This provides clear context and a prerequisite but does not explicitly state when not to use it or list alternative tools. However, the resource name and precondition make the intended usage unambiguous.

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 readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description does not add additional behavioral context beyond the slug dependency, such as whether it reads live data or cached results, or any rate limit considerations. It appropriately avoids 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?

The description is a single, clear sentence that conveys the tool's exact purpose and dependency. It contains no filler words and is front-loaded with the main action and resource.

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 well-described input schema, annotations, and sibling context. The description is complete for its role as a simple lookup tool, explicitly linking to search functions. It could optionally mention the output is a human-readable parameter set, but the presence of an output schema reduces the need for such detail.

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%, so the input schema already describes all three parameters with types, enums, and constraints. The description adds no further parameter semantics beyond reiterating the slug's source, but the schema baseline is sufficient, resulting in a 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 recommended water parameters using an exact slug from search_fish or search_plants. It specifies the verb ('get'), the resource ('water parameters'), and the direct dependency on sibling search tools, distinguishing it from other get_* and calculate_* tools.

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

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

The description explicitly instructs to use the slug returned by search_fish or search_plants, which implies the correct usage order (search first, then this tool). It does not explicitly state when not to use it or list alternatives, but the context of sibling tools makes its purpose clear.

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

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

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.