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

The annotations already mark this as idempotent and non-destructive, but the description adds useful details: writes into a download directory, requires a token for data files, checks size limits, verifies MD5s, and skips identical existing files. It goes meaningfully beyond the structured annotations, though it does not cover error or failure 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 short and front-loaded, with each sentence serving a distinct purpose: scope, safety behavior, and next steps. The parentheticals add density, but the description remains efficient and readable.

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

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

For a 20-parameter tool with no required parameters, the description gives useful context and the schema carries the individual parameter details. However, it does not explain which parameter groups are required for each download mode, how to discover file names via sibling tools, or the setup needed for the token, leaving some completeness 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% parameter coverage, but the description adds useful semantic structure by grouping parameters into download modes: data files/package ZIPs, prototype datasets, and NEON documents. It also surfaces behaviors tied to parameters like byte caps and skip-if-identical, which helps an agent form a valid parameter combination.

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 downloads NEON data files, package ZIPs, prototype dataset files, or NEON documents into a configured download directory. It does not explicitly distinguish itself from overlapping siblings such as neon_get_document or neon_list_files.

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 workflow hint ('read the CSVs ... cite with neon_get_citation') and notes that data files need a token, but it does not say when to prefer this tool over its siblings or what to do before calling it. No exclusions, prerequisites beyond the token, or alternative-tool routing are provided.

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

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

Annotations already establish readOnly, idempotent, open-world, and non-destructive behavior, so the description's job is additive. It adds meaningful behavioral detail: the location_type requirement differs by walk root, and site walks without location_type report typesAvailable. This goes beyond the schema and annotations without contradicting them.

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

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

Three sentences carry the core purpose, key constraints, and the natural follow-up action. The first sentence front-loads the resource and filters; the second adds the critical conditional behavior; the third points to the next call. There is no filler 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 an 11-parameter tool with an output schema and strong annotations, the description covers the key invocation conditions and workflow. The schema supplies most per-parameter meaning, and the output schema removes the need to describe return values. A slightly explicit note distinguishing this from neon_search_sites would make it 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?

With 64% schema description coverage, the schema already documents most parameters. The description adds only a high-level summary ('filtered by locationType ... or text, with coordinates and optional proximity') and one behavioral nuance about site walks reporting typesAvailable. This is helpful but does not materially clarify the parameters not covered by 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 states a specific verb and resource: find locations under a site, domain, REALM, or named location. It also lists meaningful filters (locationType, text, coordinates/proximity) and distinguishes itself from the singular neon_get_location by saying 'Next: call neon_get_location for one location's detail.' This gives an agent a clear, differentiated job.

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 usage context: REALM and domain walks require location_type, while site walks without it report typesAvailable. It also suggests when to chain into neon_get_location. It does not explicitly name alternatives such as neon_search_sites or state when not to use this tool, so it falls one step short of full routing guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint. The description adds valuable behavioral context beyond these: it confirms no token is required and that the tool is a small GraphQL query, which affects cost and access assumptions. It also describes output modes and filtering, but the core safety profile is covered by annotations. This adds meaningful context without contradiction.

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

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

The description is remarkably concise, with two sentences that front-load the core purpose and then add workflow guidance. Every phrase earns its place: it states what it returns, the modes, the optionality, the access requirement, and the next step. No filler or repetition exists.

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

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

For a complex tool with 12 parameters and an output schema, the description provides a clear high-level overview and a critical workflow pointer. It implies the parameter combinations (product/site, windowing, filtering, release/provisional) without exhaustively detailing them, but the schema covers the specifics. The output schema exists so return values are documented elsewhere. The only slight gap is explicit guidance on how to combine parameters for each mode, but overall it is sufficient for an agent to understand when and how to invoke it.

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

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

Parameter schema coverage is high (83%), so most parameters are individually documented. The description adds some semantic context by describing the three modes (product/site/cell) and mentions 'month ranges per release including PROVISIONAL' and 'optionally windowed and filtered,' which maps to release, provisional, start_month, end_month, and filtering parameters. However, it doesn't deeply clarify the interplay of site_codes, domain_code, product_codes, or format beyond what the schema already explains, so the added value is marginal (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 what the tool does: it returns data availability in three modes (product to sites, site to products, or a single product-site cell), including month ranges per release with provisional handling. This is a specific verb (get availability) and resource (NEON data), and it distinguishes itself from siblings by outlining distinct output structures, making it 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 gives a strong workflow hint: 'Next: call neon_list_files for a product, site and month range,' implying this tool is used for availability reconnaissance before listing files. It also notes that it works without a token and is small, which suggests it's a lightweight, preliminary query. However, it does not explicitly state when not to use it or explicitly contrast with siblings like neon_get_site or neon_search_products, so a 4 is appropriate.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral context: it follows NEON's data policy (CC BY 4.0), defaults to the newest release with a DOI, and notes that provisional data has no DOI. It also tells the agent to archive what was used, which is a meaningful behavioral instruction 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 two sentences, front-loaded with the core purpose and key distinctions (release, provisional, prototype), followed by a practical next-step instruction. Every sentence earns its place, and the structure is efficient for an agent scanning for 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?

The tool has 7 parameters, an output schema, and rich annotations. The description covers the main use cases and the policy context, but it doesn't detail the output format beyond 'citation text and BibTeX' (though the output schema likely covers this). It also doesn't explain edge cases like what happens if no release is found, but the schema and annotations carry much of the burden. Overall, it's complete enough for an agent to select and invoke 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 86%, so the schema already documents most parameters well. The description adds context for the 'release' parameter (defaults to newest with a DOI) and clarifies the 'provisional' parameter (no DOI, not with an explicit release). It also explains the 'prototype_uuid' parameter's purpose. This goes beyond the schema's descriptions and helps the agent understand the citation-specific 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 clearly states the tool's purpose: generating NEON-format citation text and BibTeX for a data product in a release, provisional data, or prototype dataset. It distinguishes itself from siblings by focusing on citation generation rather than data retrieval or search, and it names the specific resource types it covers.

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 explains when to use this tool: for citing data products in releases, provisional data, or prototypes. It also provides a next-step instruction ('include the citation with any results') and directs the agent to a guide for rules, which is strong usage guidance. It doesn't explicitly name alternatives, but the sibling list makes it clear this is the citation-specific tool.

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 valuable behavioral context beyond that: text extraction is 'extracted in memory and paged by character offset', which warns the agent that large text is not returned all at once and must be paged. It also discloses the 'No token' auth requirement and the optional PDF dependency (neon-mcp[pdf]) via the schema. It does not mention rate limits or failure modes, but the in-memory paging behavior is a meaningful disclosure.

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

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

Three sentences with no filler. The first sentence front-loads the core purpose and return fields, the second states the key constraint (no token) and the optional text mode, and the third gives actionable next steps. Every sentence earns its place and the structure is easy to scan.

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

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

For a read-only metadata tool with an output schema, the description is nearly complete. It covers the two lookup modes, the optional text extraction, pagination, and the sibling download tool. The only missing context is a brief note on when to use spec_number vs url (e.g., which is preferred), and the fact that extract_text requires the optional pdf extra is only in the schema, not the description. These are minor gaps given the output schema and annotations.

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 71%, so the schema already documents most parameters. The description adds meaning by explaining the relationship between spec_number and url (two alternative lookup keys), and by clarifying that char_offset is the pagination mechanism for extracted text. It also ties extract_text to the paging behavior. The only minor gap is that the description doesn't explicitly explain how pages interacts with extract_text, but the schema covers the format examples.

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

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

The description states a specific verb ('Get') and resource ('Metadata of a NEON document'), and enumerates the exact fields returned (type, size, file name, description, products that reference it). It also distinguishes the optional text-extraction mode from the metadata mode, and names the sibling tool (neon_download_files) it is not. This clearly differentiates it from siblings like neon_get_product or neon_get_citation.

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 'No token' (no authentication needed), and gives a concrete next-step routing: 'Next: page through text with char_offset, or call neon_download_files(spec_number=...) on stdio.' This tells the agent when to use this tool versus the download sibling, and how to continue after the first call. It also implies the two lookup modes (by spec number or documents URL) without needing to open the schema.

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 operation read-only, idempotent, and non-destructive happy path. The description adds valuable behavioral details beyond those annotations: names are case-sensitive, children are paged and pruned by location_type, and optional includes control parent chain, history, polygon, and children. It does not discuss error behavior, but the output schema covers the response shape.

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?

Two sentences, no filler. The first sentence front-loads the main purpose and payload, while the second packs two useful usage details: case-sensitivity and the recommended follow-up sibling. Every phrase earns its place.

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

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

Given the read-only annotations, a rich output schema, and a sibling list, the description is largely complete: it names the returned data, optional inclusions, pruning behavior, pagination concept, and a follow-up tool. The main gap is the lack of explicit semantics for the limit/offset/depth parameters, though their names and schema constraints make them reasonably inferable.

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 only 50%, and the description compensates partially by explaining the include semantics ('parent chain, location history, polygon and paged children') and the pruning role of location_type. However, three parameters—children_limit, children_offset, and hierarchy_max_depth—lack schema descriptions and are not mentioned in the tool description, leaving a real semantic gap despite self-explanatory names.

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

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

The description opens with 'One named location in depth' and enumerates the exact data returned: coordinates, UTM, elevation, orientation and offsets, properties, active periods. It also lists optional additions (parent chain, history, polygon, children), making the operation's scope unambiguous and distinguishing it from listing-oriented siblings like neon_find_locations.

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?

It provides a concrete follow-up instruction: 'Next: call neon_find_locations to list locations of a type under it,' which implies this tool is for deep single-location retrieval while neon_find_locations handles children listing. The guidance is clear but implicit; there is no explicit when-not-to-use statement or comparison with other siblings like neon_get_site.

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, openWorldHint, idempotentHint, and destructiveHint=false, so the tool is known to be safe. The description adds useful behavioral context: it explains that change logs are paged and availability rows can be per-site, and that sections are opt-in. It also mentions pagination via limit/offset implied by 'paged'. This goes beyond the annotations without contradicting them.

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

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

Two sentences with no fluff. The main capability is stated first, followed by optional features and a clear pointer to next steps. Every clause contributes information, and the structure is 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?

For a tool with 8 parameters and an output schema, the description covers the key aspects: what it returns, how to specify the product, opt-in sections, pagination behavior, and a pointer to related tools. The output schema presumably details the return structure, so the description need not repeat that. No critical information for calling it correctly is missing.

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 50% (4 of 8 params have descriptions). The description adds meaning for the less-documented parameters: it mentions pagination for change_logs and availability (giving context to limit/offset), and explains that include[] controls opt-in sections. It also clarifies that product accepts a code or name. This compensates for the schema gaps and adds value 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 that the tool retrieves a single data product with a specific set of fields (codes, name, team, status, themes, keywords, releases with DOIs, availability summary) and that opt-in sections can add more detail. It distinguishes from sibling tools like neon_get_availability (per-site availability) and neon_get_citation by explicitly pointing to them as follow-ups.

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 says it accepts a product code or name and suggests next steps (call neon_get_availability or neon_get_citation), implying this is for fetching a specific product rather than searching or listing. It does not explicitly list exclusions (e.g., when to use neon_search_products), but the 'one data product' phrasing and sibling names provide enough context. The guidance is clear but not exhaustive.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior. The description adds useful behavioral context by explaining what is included by default, that files come with sizes/MD5s/signed URLs, and that descriptions/citations/related products are optional. 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 two sentences with no filler. It front-loads the core return payload, then gives actionable next steps. Every sentence contributes to selection or invocation.

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, annotations, and a clear next-step pointer, the description covers the main behavior well. It is slightly incomplete on pagination/truncation parameters (files_limit, files_offset, text_budget), but those are partially self-explanatory and the schema provides constraints.

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 about 50%, so the description needs to compensate. It does add meaning for the include options by mapping them to descriptions, citations, and related products, and clarifies default file inclusion. However, it does not explain files_limit, text_budget, or files_offset, which are only represented by names and bounds in 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 returns one prototype dataset with a specific set of fields (title, abstract, years, version, DOI, themes, teams, sites) plus file metadata and signed URLs by default. It also distinguishes itself from a search/list operation by saying 'One prototype dataset' and names follow-up sibling 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 gives clear workflow context by telling the agent what to do next: call neon_download_files or neon_get_citation with the prototype_uuid. It does not explicitly state when not to use this tool or compare it to neon_search_prototype_datasets, 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 this as read-only, idempotent, and non-destructive, so the bar is lower. The description adds useful behavioral detail: unknown tags fail with the list of valid releases, and product results are paged and filterable.

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?

Three compact sentences front-load the core capability, then add the error behavior and a clear next-step pointer. Every sentence contributes new information with no redundancy.

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

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

For an 8-parameter tool with an output schema and safety annotations, the description covers the main selection modes, optional includes, filtering/pagination, error behavior, and a follow-up action. Nothing essential is missing for an agent to decide to call it and interpret the result.

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

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

Schema coverage is 75%, so the baseline is 3, but the description adds meaning by explaining that site_code and product_code return items 'exactly as published in that release' and that products are 'paged, filterable'. This enriches the raw parameter names and schema descriptions.

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 and resource: getting one NEON release, its data products with DOIs, sites, artifacts, or a single product/site as published in that release. It clearly distinguishes this tool from siblings like neon_get_site, neon_get_product, and neon_get_citation by emphasizing release-pinned data.

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 for when to use the tool: when you need release-specific data, optionally including sites or artifacts, or a product/site as published in that release. It also names a follow-up tool (neon_get_citation) for citations, though it doesn't explicitly list exclusions for all 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 readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds substantial behavioral context beyond annotations: an API token is required, ambiguous tags trigger class disambiguation or candidate listing, and degree=N extends the result to relatives N steps away. This enriches the agent's mental model of the operation.

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

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

The description is one dense but well-organized paragraph that front-loads the core purpose, then covers identifiers, degree behavior, and next-step guidance. Every clause earns its place, though a bit of restructuring into separate sentences would improve scanability.

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 11 parameters, an output schema, and strong annotations, the description covers the essential invocation logic: what a sample is, how to identify it, how degree works, and how to traverse the graph. It does not explain events_limit, limit, or offset, but those are minor pagination controls already structured in the 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 73%, and the schema describes fields like degree, fields, barcode, sample_tag, and include_events. The description adds value by grouping identifiers into alternative lookup paths (tag+class, UUID, barcode, archive GUID) and explaining that degree controls relative expansion. It does not clarify pagination parameters like limit and offset, but the schema covers those with defaults and ranges.

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

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

The description names a specific verb ('get') and a specific resource ('a physical sample's custody chain'), and clearly differentiates this from sibling tools like neon_get_site or neon_get_product by stating it returns identifiers, events, and parent/child relationships. It also enumerates the exact identifier types accepted, which leaves no ambiguity about what the tool operates on.

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 for when to call the tool: when you need a custody chain and can identify the sample by tag, UUID, barcode, or archive GUID. It also explains how to continue traversal ('follow parent or child identifiers with another neon_get_sample call'), though it does not explicitly name alternative tools or state when not to use it.

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

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

Annotations already declare readOnlyHint, idempotentHint, and openWorldHint, so the safety profile is covered. The description adds useful behavior beyond that: default inclusion of data products with month ranges and provisional counts, plus optional sections. The phrase 'every data product' slightly conflicts with the schema's default products_limit of 100, but this is minor and not an annotation contradiction.

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

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

Two sentences, front-loaded with the most important return-content information, followed by a useful next-step pointer. No filler or repetition of schema details.

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 output schema and strong annotations, the description covers the essential defaults, optional sections, and downstream calls. It does not mention pagination parameters, but those are visible in the input schema and are secondary for a single-site get operation.

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

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

Schema description coverage is 67%, and the description helps map include options to their contents (releases, full description, location with elevation/UTM/properties). However, products_limit and products_offset are undocumented in the schema and the description does not compensate for those parameters, leaving a gap.

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

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

The description clearly identifies a singular resource ('One field site') and enumerates exactly what is returned: name, type, state, domain, coordinates, DEIMS id, and data products with month ranges and counts. This distinguishes it from sibling search/list tools like neon_search_sites and product-level tools like neon_get_product.

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 actionable context by saying to call neon_get_availability or neon_list_files next for a product at this site. It does not explicitly say 'use neon_search_sites when you need multiple sites', but 'One field site' and the next-step guidance imply the appropriate usage boundary.

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?

Goes well beyond the readOnlyHint/idempotentHint annotations by disclosing specific guard rails: allow-listed root fields, depth <= 8, one __type/__schema call, byte-budget pruning with truncatedPaths, and 'No token is sent.' This gives the agent strong operational expectations before calling.

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?

Four dense sentences deliver purpose, constraints, alternatives, and next-step guidance without redundancy or filler. The most important scoping information is front-loaded before guard rails and routing advice.

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 generic GraphQL fallback tool with an output schema, the description covers access type, resource, safety limits, response pruning behavior, authentication expectations, routing to dedicated siblings, and a pointer for schema details. Nothing operationally critical is missing.

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 each parameter already has meaningful descriptions, so the description does not need to repeat them. The description adds related behavioral context (pruning, guard rails) but not per-parameter semantics, keeping this at the baseline score 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?

States a specific verb and resource: read-only GraphQL against NEON's public metadata endpoint. It also distinguishes itself from siblings by explicitly positioning the tool as covering shapes 'the other tools do not cover,' preventing confusion with the many dedicated product/site/availability 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?

Provides clear usage guidance: use for shapes other tools do not cover, and prefer dedicated tools for products, sites, and availability. It also warns that only query operations are allowed and points the agent to read the schema reference for types, giving practical direction for correct invocation.

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?

Beyond the readOnly/idempotent annotations, it discloses that a NEON API token is required, that signed URLs are valid for about 7 days, and that package ZIP links are only for a single site-month. It also reveals response-shaping behavior through the detail parameter, which is valuable non-obvious context.

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?

Three dense sentences convey scope, output contents, authentication, URL expiry, response-size alternatives, and the downstream download tool. There is no filler, and the core purpose is 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?

For an 18-parameter tool with a rich output schema and readOnly/idempotent annotations, the description provides the essential missing context: token requirement, URL behavior, detail modes, and the recommended follow-up tool. Nothing critical is left unexplained.

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 89%, so the schema already documents most parameters. The description adds extra meaning for detail ('sizes a pull without listing files'), include_urls ('signed URLs ~7 days'), and package ZIP links, going beyond what the parameter descriptions alone convey.

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

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

The description names a specific verb and resource: listing NEON data files for a product across sites and months, and enumerates the returned fields (names, kinds, tables, HOR/VER/TMI, sizes, MD5s, signed URLs, ZIP links). It is clearly distinct from the 'download' sibling and from site/product metadata lookup 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 gives clear workflow context: list first, then either call neon_download_files with the same selectors or use the returned URLs. It also explains when to use detail='summary' or 'site_months' to size a pull. It stops short of naming when this tool should not be used versus other siblings, so it is not a full 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/openWorldHint/idempotentHint, and the description adds value by disclosing that releases are immutable, carry per-product DOIs, newer data are PROVISIONAL, and manifest URLs expire (also in schema). 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?

Three sentences with no filler: purpose and ordering come first, key properties and caveats second, and the logical follow-up call last. Each clause adds information that helps selection or invocation.

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 single optional parameter, rich annotations, and an output schema present, the description covers what the tool returns and how it relates to sibling tools. Nothing needed for correct invocation is missing.

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

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

There is only one optional parameter and the schema describes it fully (include signed manifest URLs, large, expire in 7 days). The description mentions manifest artifacts, but the parameter semantics are carried by the schema, so the description adds no essential parameter-level detail beyond the baseline.

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

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

The description names the specific operation ('List NEON data releases'), states the scope ('All ... newest first'), and lists the key returned attributes (generation dates, product counts, manifest artifacts). It also distinguishes itself from the sibling neon_get_release, which covers one release's products and DOIs.

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?

It explicitly points the agent to the next appropriate tool ('Next: call neon_get_release for one release's products and DOIs'), making the boundary between list-all and get-one clear. The mention of immutability and provisional data also hints at when release metadata is stable.

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 cover the read-only, idempotent, non-destructive safety profile. The description adds useful behavioral context beyond those hints: no authentication token is required, and the tool returns descriptions and supports two distinct filtering behaviors. 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 compact and front-loaded, with the core purpose stated first, followed by auth and workflow guidance in short fragments. The final list of neon_get_sample arguments is slightly more than needed for selecting this tool, so it is not perfect.

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 read-only listing tool with rich annotations and an output schema, the description is complete enough: it states the resource, filter modes, auth requirement, and next step. The remaining details, such as pagination defaults, are available in the input 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 50%, and the description mostly restates what the schema already says about query and sample_tag. It contributes an example class key but does not explain limit, offset, or pagination behavior, so it does not fully compensate for the undocumented parameters.

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

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

The description clearly states a specific verb and resource: 'List NEON's supported sample classes' and gives an example class key. It also distinguishes the two filter modes—text and sample tag—so an agent can tell this apart from list_files, list_releases, and get_sample.

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 usage context: it is filterable by text or by sample tag, requires no token, and is positioned as the step before neon_get_sample. It does not explicitly state when not to use it or name alternatives, but the workflow guidance is strong enough.

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, openWorldHint, idempotentHint, and destructiveHint=false. The description adds meaningful behavior beyond that: the conditional network request when check_api=true, the explicit statement that the token is never revealed, and the linkage of token availability to data-file/sample access.

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 front-loaded with the core purpose and remains compact while covering capabilities, the conditional API check, a security guarantee, and a next-step suggestion. A few terms like 'catalog warmth' could be seen as jargon, but every sentence contributes useful information.

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

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

For a low-complexity tool with one optional parameter, a rich output schema, and safety annotations already present, the description covers everything needed: purpose, conditional behavior, security posture, and an orientation to the next appropriate tool. Nothing essential is missing.

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 the check_api parameter is already well documented in the schema with its default, size, and purpose. The tool description largely repeats the schema's parameter explanation rather than adding materially new semantics, so the baseline 3 applies.

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

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

The description clearly identifies this as a 'Liveness and capability report' for the neon-mcp server, enumerating specific items like server version, token availability, download status, and rate-limit headroom. It is unambiguously distinct from the data-access siblings and even directs to neon_search_products for finding a data product.

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 a clear context: this is an initial status/capability check, and it suggests calling neon_search_products next. It also explains when check_api=true is useful (testing reachability and rate-limit headers). It does not explicitly state when not to use it, but the router hint and report framing make the intended usage 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?

Annotations already declare readOnlyHint and idempotentHint, and the description adds valuable behavioral context: it is served from a cached catalog, requires no token, returns ranked results with facets, includes site count and month range, and matches bare product codes exactly. 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?

Three sentences: the first states scope and filters, the second explains the cache/no-token access and exact-code matching, the third routes to follow-up tools. Every sentence earns its place and the key information is 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?

For a 14-parameter search tool, the description covers purpose, filter dimensions, access behavior (cached, no token), result features, exact-match behavior, and follow-up workflows. The output schema and high parameter coverage handle the remaining details.

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 79%, so the schema already documents most parameters. The description reinforces the query semantics ('bare code matches exactly') but does not meaningfully add parameter-level details beyond what the schema provides for the uncovered sort/limit/offset 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 states a specific verb ('Find') and resource ('NEON data products') and enumerates the filter dimensions (keywords, theme, science team, level, status, site, domain, date coverage). This clearly differentiates it from sibling search tools like neon_search_prototype_datasets and neon_search_taxonomy.

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: search across many dimensions, served from a cached catalog. It also provides explicit next steps ('Next: call neon_get_availability... or neon_get_product') but does not explicitly state when not to use this tool versus a direct get_product 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, so the safe-read profile is structurally covered. The description adds value beyond annotations by disclosing 'No token' (auth requirement), the DOI/version per-dataset data model, and the facet behavior, plus a next-step pointer. No contradiction with annotations found.

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?

Three tight sentences with the core purpose front-loaded in sentence one. The 'Each has its own DOI and version' sentence is mildly tangential to calling the tool, but 'No token' and the next-step instruction each earn their place. Slightly more than strictly necessary, but no wasted words.

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

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

For a 10-parameter, all-optional search tool with an output schema present, the description conveys the search scope, the filter dimensions, auth status, and the correct follow-up tool. Return-format details are covered by the output schema and the read-only behavior by annotations. The only minor gap is not elaborating on the facet behavior, but this is acceptable.

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 80%, so most parameters are already well documented in the input schema itself. The description's prose enumeration of filters (text, theme, science team, site, years, file type, publication flag) maps cleanly to query, theme, science_team, site_code, start/end_year, file_type, and is_published, but adds no granular detail beyond what the schema already states. 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 opens with a specific verb-resource pair ('Search NEON's prototype datasets') and immediately disambiguates the resource meaning ('early or experimental data outside the standard products'), which distinguishes it from sibling neon_search_products. It enumerates the full filter set (text, theme, science team, site, years, file type, publication flag) so an agent knows exactly what this search covers.

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 'outside the standard products' implies a contrast with standard-product searches, and the closing instruction 'Next: call neon_get_prototype_dataset with a uuid for files' gives a concrete follow-up route. However, it never names an explicit alternative (e.g., neon_search_products) or states a when-not-to-use condition, so the routing is implied rather than stated.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds that the catalog is cached and no token is needed, which informs the agent about potential staleness and lack of authentication burden. It also mentions that include_elevation triggers one extra cached request, a behavioral nuance beyond the schema. Minor gap: no mention of rate limits or response size, but annotations carry the safety 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, information-dense sentence that front-loads the primary purpose and search dimensions, followed by a brief note on caching and next steps. No wasted words; every clause carries meaning.

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

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

With 12 parameters, most of which are optional and well-described in the schema (75% coverage), an output schema exists, and annotations cover safety, the description doesn't need to repeat parameter details. It adds the essential search modes and the important note about cached catalog and token-less operation. It is complete for an agent to decide whether and how to call this tool, though it could mention that output is paginated via limit/offset, but the schema already defines those defaults.

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 75%, so most parameters have descriptions in the schema. The description adds that proximity is 'nearest first' and that elevation includes UTM, which are not in the schema. It also clarifies that query can match state/domain names, complementing the schema's examples. Since coverage is high, the description's additions are a bonus, not compensation, justifying a 4 rather than 5.

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 ('Find') and resource ('NEON's 81 field sites') and enumerates the search dimensions: code, name, state, domain, site type, product availability, and proximity. This clearly distinguishes it from sibling tools like neon_get_site (which retrieves a single site) and neon_search_products (which searches products, not sites).

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 that the tool searches a cached catalog and requires no token, which guides the agent on prerequisites. It also tells the agent what to do next ('Next: call neon_get_site or neon_get_availability(site=...) for a siteCode'), giving clear routing to sibling tools. This is above and beyond basic usage 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 indicate a safe read-only operation, and the description adds useful behavior beyond that: results are paged, no token is required, rows retain Darwin Core keys, and exact-name search falls back to genus. This is meaningful operational context that the agent would not otherwise know.

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?

Three sentences with no filler, front-loading the primary search modes and immediately adding the most important operational notes: no token, pagination, output keys, and the sibling fallback. Every sentence earns its place.

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

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

Despite 13 parameters, the description covers the main usage axes and points to the right sibling for product data. An output schema exists, so return values do not need elaboration. It stops just short of complete by not summarizing the taxon_type_code-versus-rank conflict or verbose-mode caveat, though those live in the schema.

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

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

Schema description coverage is only 46%, so the description partially compensates by explaining the broad modes (taxon type, rank, exact scientific name) and the genus fallback. However, several rank parameters like kingdom, phylum, division, order, and family are not elaborated in the description beyond the phrase 'taxa by rank', leaving the agent to rely on the sparse 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 names a specific verb-resource pair ('search NEON taxonomy') and states the three search modes: taxon type, rank, and exact scientific name with genus fallback. It also distinguishes itself from the sibling neon_search_products by pointing there for data about the taxa.

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?

It clearly scopes the tool to taxonomy lookups and gives practical routing guidance: paginate with page.nextOffset or switch to neon_search_products for taxon data. It does not explicitly say when not to use this tool, but the alternative is named and the context is clear.

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