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

Annotations already declare readOnlyHint=true and openWorldHint=true. The description adds useful context about the ID format but does not disclose behavior for missing IDs, error conditions, or the nature of the response. With annotations covering safety, this is adequate but not rich.

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

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

The description is a single, front-loaded sentence that immediately states the action and key identifier format. Zero wasted words.

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

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

For a simple fetch-by-ID tool with safe-read annotations, the description is functional but leaves gaps: it does not mention the 'raw' parameter, potential error responses, or return shape. Given the low complexity, it is minimally viable but not fully complete.

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

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

The schema has 0% coverage, and the description only indirectly explains funder_id by stating it is a Crossref Funder Registry id. The 'raw' boolean parameter is completely unexplained. The description fails to compensate for the low 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 a specific verb 'fetch' with a clear resource 'one funder' and a precise identifier ('Crossref Funder Registry id'). This distinguishes it from sibling tools like search_funders (search across funders) and get_funder_works (works by funder).

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: use when you have a specific funder ID. However, it does not explicitly state when to avoid this tool or mention alternatives like search_funders for searching by name. Guidance is implicit rather than explicit.

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 openWorldHint=true. The description adds no behavioral details like pagination behavior, sort semantics, or return shape, so it provides little 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?

Single sentence, immediately states purpose, no 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?

Tool has 9 parameters and no output schema; a one-line description is insufficient to guide correct usage for filtering, sorting, and pagination. Siblings suggest a richer API surface.

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

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

Schema description coverage is 0% and the description only names funder_id. Other parameters (raw, rows, sort, order, query, cursor, filter, offset) are left undefined; schema offers only defaults/titles, no explanation.

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

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

Description states 'List works funded by a given funder id' - clearly specifies action (list), resource (works), and unique parameter (funder id), distinguishing it from siblings like search_works or get_member_works.

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 context: use when you have a funder id and want its works. Doesn't mention alternatives or exclusions, so not 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 and openWorldHint, so the safety profile is known. The description adds the ISSN format and hyphen flexibility, which is parameter semantics rather than behavioral context. It does not describe return format, error handling, or rate limits, but annotations lower 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 states the action and key parameter. There is no wasted wording, and the ISSN format is included efficiently.

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

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

For a simple get-one tool, the description covers the identifier and format, but it omits explanation of the 'raw' parameter and the return value. With no output schema, the agent is left without details about what the tool returns or how 'raw' behaves, leaving notable 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 description adds meaning to 'issn' by specifying the format (NNNN-NNNN; hyphen optional), which is not in the schema. However, the 'raw' boolean parameter remains completely unexplained, and with 0% schema description coverage, the description does not fully compensate for 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 a specific verb ('Fetch'), identifies the resource ('one journal'), and specifies the unique identifier ('by ISSN'), clearly distinguishing it from siblings like search_journals and get_journal_works.

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 when a specific ISSN is available and a single journal is needed, but it does not explicitly state when to prefer this tool over search_journals or when not to use it. No alternatives or exclusions are mentioned, leaving guidance implicit.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the description does not need to repeat that. However, it adds no additional behavioral context such as pagination behavior, default return format, or performance implications. The only extra detail is 'by ISSN', which is already evident from the parameter 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 focused sentence, immediately stating the tool's purpose. It is concise and well-structured, with no extraneous 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 tool has 9 parameters, no output schema, and many sibling tools, the description is too sparse. It does not clarify the nature of the response, the meaning of optional parameters, or how the results are ordered or paginated, leaving the agent without enough context for effective use.

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

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

Schema description coverage is 0%, with 9 total parameters. The description only mentions ISSN, leaving raw, rows, sort, order, query, cursor, filter, and offset entirely unexplained. The description fails to compensate for the lack of parameter documentation 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 uses a specific verb 'List' and clearly identifies the resource 'works published in a given journal' with the method '(by ISSN)'. This distinguishes it from sibling tools like get_work, search_works, and get_journal.

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 the tool is for listing works of a specific journal identified by ISSN, but it does not explicitly compare with alternatives or state when to use this over search_works or get_work. No exclusions or conditions are mentioned, so usage guidance is only implicit.

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

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

Annotations already indicate readOnlyHint=true and openWorldHint=true. The description adds no further behavioral context such as output format, error handling, or the effect of the 'raw' parameter. It only restates that it fetches a member, which is already clear from the name and 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 is front-loaded with the action and resource. It contains no redundant information and is appropriately sized for a simple fetch tool.

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

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

The tool is simple with one required parameter and no output schema. The description adequately conveys the core purpose and identifier type, but it omits details about the 'raw' parameter and return structure. Given the lack of output schema and parameter descriptions, a bit more context would make it complete.

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

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

Schema description coverage is 0%, so the description must compensate. It clarifies that 'member_id' is numeric, but the 'raw' parameter is entirely unexplained. The description only partially adds meaning to one of two parameters, leaving the other undefined.

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 'Fetch' with a specific resource 'one member (publisher)' and the key identifier required ('numeric Crossref member id'). This distinguishes it from sibling tools like 'search_members' (for searching) and 'get_member_works' (for works), so the tool's purpose is unambiguous.

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

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

The description implies when to use this tool: when you have a specific numeric Crossref member ID and need that member's details. It does not explicitly mention alternatives like 'search_members' for finding IDs, but the phrase 'by numeric ... id' provides clear context and exclusion of search use cases.

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 readOnlyHint and openWorldHint annotations already cover the safety profile, and the description adds no contradictions. It adds minimal behavioral context beyond the annotations (e.g., no mention of pagination, sorting, or response format), so the description adds some but not rich 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?

The description is a single, front-loaded sentence with no filler. It efficiently conveys the core purpose without waste, 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?

With no output schema, the description should explain what the tool returns and how parameters like cursor/offset/rows control pagination. It provides none of this, leaving the agent to guess about return structure and pagination behavior. The description is too skeletal for a tool with this complexity.

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

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

Schema description coverage is 0%, so the description must compensate for parameter meaning. It only identifies 'member_id' as the key input, but ignores the other 8 parameters (raw, rows, sort, order, query, cursor, filter, offset) and their semantics. This is a significant gap for a tool with 9 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 'List works published by a given member id', which is a specific verb+resource+scope. It distinguishes from siblings like search_works (broad search), get_work (single work), and get_journal_works/get_funder_works (other entity-scoped lists) by specifying member id.

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 wording implies use when you have a member id and need their published works, but it provides no explicit guidance on alternatives or exclusions. No mention of when to prefer this over search_works or other list 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 provide readOnlyHint and openWorldHint. The description adds one useful constraint (no list endpoint) but does not disclose other behavioral traits like the meaning of the raw parameter or the response structure. This is minimal added context 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 extremely concise: two sentences with the main purpose front-loaded and a second sentence that adds a relevant limitation. No fluff or redundancy.

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

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

The tool is relatively simple with one required parameter and no output schema. The purpose and a key limitation are clear, but the raw parameter is undocumented and the return value is not described, leaving some ambiguity for the agent. Overall it is adequate but has clear 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 no descriptions for parameters (0% coverage). The description only gives an example for owner_prefix but leaves 'raw' entirely unexplained. This does not compensate for the lack of schema documentation, leaving the agent uncertain about the raw parameter's purpose.

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 a specific verb ('look up') and resource ('owner of a DOI prefix'), and provides a concrete example ('10.1038'). This distinguishes it from sibling tools like get_work or get_member, which target different entities.

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 tells users that Crossref only exposes /prefixes/{owner_prefix} and that there is no list endpoint, setting expectations that a specific prefix must be provided. However, it does not explicitly mention when not to use the tool or contrast it with alternatives.

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

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

Annotations already declare readOnlyHint=true, covering the read-only safety profile. The description adds the 'by id' scoping and an example, but does not disclose other behavioral aspects such as error handling, pagination, or the effect of the 'raw' parameter. This is acceptable given the read-only annotation, but no additional context is provided beyond the purpose.

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

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

The description is a single, focused sentence with no filler. It front-loads the verb and resource, and uses an example to convey format. 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 the tool's simplicity (2 params, no output schema, no nested objects), the description provides the core context: fetching a single work type by id. However, it omits the 'raw' parameter behavior and any error-handling notes, which is a slight gap for a complete understanding.

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

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

With schema_description_coverage at 0%, the description should compensate for parameter documentation. It provides an example for type_id, which adds meaning, but it completely omits the 'raw' parameter. The description fails to explain what 'raw' controls, leaving the agent without guidance on half of 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 clearly states the tool fetches one work type by id, providing a specific verb (fetch), resource (work type), and scope (by id). The example 'journal-article' further clarifies the expected input. This distinguishes it from sibling tools like list_types 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?

The description implies usage when a single work type id is known, but it does not explicitly mention when to use this tool versus alternatives like list_types or other getters. There are no exclusions or alternative references, so guidance is minimal but not misleading.

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 behavioral details beyond the readOnlyHint and openWorldHint annotations: it states that a bare DOI or doi.org URL is accepted, that simplified fields are returned unless raw=True, and that a structured error is returned for nonexistent DOIs. These are useful operational details that annotations do not 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 three sentences, front-loaded with the core purpose, and every sentence contributes unique information (input format, return behavior, error handling). 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 tool with only two parameters and no output schema, the description is largely complete. It covers input formats, return behavior, and error handling. The only minor gap is that it doesn't explicitly state what 'simplified fields' includes or provide an example, but the annotations and sibling context allow an agent to infer enough for selection and invocation.

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

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

The input schema provides only parameter names and types with 0% description coverage. The description compensates fully by explaining that 'doi' accepts a bare DOI or doi.org URL, and that 'raw' controls whether simplified fields are returned. This adds clear 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 opens with 'Fetch a single work's metadata by DOI,' which is a specific verb+resource+scope statement. It clearly distinguishes from siblings like get_work_quality, get_work_references, and search_works by focusing on metadata for a single work identified by DOI.

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 that this tool is for fetching a single work's metadata by DOI, and specifies accepted input formats (bare DOI or doi.org URL). However, it does not explicitly compare against sibling tools or explain when to use this versus alternatives like get_work_quality or get_work_references. Usage is implied rather than explicitly guided.

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, so the read-only nature is covered. The description adds the specific behavior of returning the registration agency, which is useful context. However, it discloses no other behavioral traits such as what 'raw' actually does, rate limits, or potential variations in output. Since annotations cover the main safety profile, the description meets a baseline but adds limited extra 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?

The description is a single, front-loaded sentence that states the core purpose immediately. It contains no filler or redundant information, earning a perfect score for brevity 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?

The tool is relatively simple with two parameters and no output schema. The description covers the primary purpose but omits details about the 'raw' parameter and does not clarify what the response looks like. The name mismatch also reduces completeness. For a low-complexity tool, this is adequate but has clear gaps.

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

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

Schema description coverage is 0%, and the description only implicitly references the 'doi' parameter through the phrase 'for a DOI'. It gives no explanation for the 'raw' boolean parameter, which remains ambiguous. The schema itself provides no descriptions, so the description fails to compensate for the lack 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 clearly states the tool's action ('Look up the registration agency for a DOI') with a specific resource (DOI) and gives examples (Crossref, DataCite). This distinguishes it from sibling tools like get_work or search_works. However, the tool name 'get_work_quality' suggests a different purpose, creating minor confusion and the description does not explicitly address the name mismatch.

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. It only implies usage when you need a DOI's registration agency. There are no exclusions, prerequisites, or references to sibling tools, so the agent receives no decision support.

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 and open-world behavior; the description adds specific transparency by disclosing the hard cap of 50 for limit and that it reads the `reference` field, providing details beyond the generic 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 main purpose, and every sentence provides useful information without 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?

The tool is simple, and the description covers the core functionality, input (DOI), and a key constraint (limit cap). It does not detail the return structure, but the description's phrase 'reference list' and 'works it cites' gives a reasonable expectation. Given no output schema, this is 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?

With zero schema descriptions for parameters, the description partially compensates by explaining that doi identifies the work and that limit is capped at 50. However, the `raw` parameter is not explained, leaving a semantic 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 states the action ('List') and the resource ('reference list of a work'), and further clarifies it's the works it cites, distinguishing it from sibling tools like get_work or get_work_quality.

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 on when to use the tool (to retrieve references/citations of a work by DOI), but it does not explicitly mention alternatives or exclusions compared to other work-related 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: true and openWorldHint: true, covering the safety profile. The description adds valuable context beyond these annotations: it specifies that the list contains licenses 'Crossref has seen' (i.e., actual observed licenses, not an authoritative registry) and that no single-license lookup exists. This clarifies the tool's empirical nature and limitation, going beyond the basic annotation hints.

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

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

The description is extremely concise, consisting of two sentences with no wasted words. It front-loads the core purpose and follows up with a key limitation. 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?

For a simple list tool with read-only annotations, the description covers the core function and a key limitation. However, it is incomplete regarding parameter semantics and does not describe the return format or pagination behavior. Given the low parameter coverage and no output schema, more detail would be needed for full completeness, but the tool is simple enough that the current description is minimally viable.

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

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

Schema description coverage is 0% and the description provides no explanation for the four parameters (raw, rows, query, offset). With such low coverage, the description was expected to compensate, but it mentions none of the parameters, leaving the agent to guess at their meaning. This is a significant gap, especially since query and raw could have nuanced behavior.

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's function: 'List licenses Crossref has seen.' It uses a specific verb (List) and resource (licenses) with a clear scope (Crossref has seen). It also distinguishes from any potential single-license lookup by stating 'No single-license lookup exists,' which sets it apart from sibling tools that include individual get endpoints for other resources.

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 that this is the only license-list endpoint and explicitly notes that no single-license lookup exists, which guides the agent to use this tool whenever license information is needed. However, it does not provide explicit when-to-use/when-not-to-use scenarios or describe alternative tools, though no direct sibling alternative exists.

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 openWorldHint=true, so the safety profile is clear. The description adds the specific resource domain (Crossref work types) but no behavioral traits like pagination or raw output handling. 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?

A single, front-loaded sentence that states the purpose and gives examples. 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 list tool, the core functionality is stated adequately. However, the lack of parameter explanation (especially 'raw'), no usage guidance, and no return-value description leave gaps, though the annotations mitigate some concerns.

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

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

With 0% schema description coverage, the description must compensate by explaining parameter meaning. It does not mention any of the three parameters; 'raw' in particular is left ambiguous, and rows/offset are only implied by naming.

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 ('list') and resource ('Crossref work types'), with concrete examples. It clearly distinguishes from sibling tools like get_type, which retrieves a specific 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?

No guidance is provided on when to use this tool versus alternatives such as get_type. The sibling context implies a distinction, but the description itself lacks any such 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 declare readOnlyHint=true. The description adds useful context by specifying the return payload (server name and version) and confirms this is a non-destructive health check. 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?

Two short sentences with no fluff. The description is front-loaded with 'Health check tool' and immediately specifies the return value, 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?

For a simple health-check tool with no parameters, the description fully communicates its purpose and output. The sibling set consists exclusively of data-querying tools, so usage context is effectively 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 tool has zero parameters, so the schema fully covers inputs. Per the rubric, a zero-parameter tool gets a baseline of 4; the description adds no unnecessary parameter details.

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

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

Clearly identifies the tool as a health check that returns server name and version. It is distinct from sibling data-retrieval tools, which all focus on querying academic 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?

Implies usage as a health check, and sibling context makes it obvious when to use this tool (e.g., to verify server connectivity). However, it does not explicitly state when to use vs alternatives or when not to use.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the description need not restate safety. It adds return field info ('funder id, name, location'), which is useful, but it does not disclose pagination behavior, cursor/offset semantics, the effect of 'raw', or any other side effects or constraints beyond the annotation. This matches the baseline for annotation-backed descriptions but adds relatively little behavioral 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?

The description is two short sentences, front-loaded with the core action and resource. No filler words. Every sentence conveys necessary information: what the tool does and what it returns.

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 moderately complex with 5 optional parameters and no output schema. The description only covers the basic search and a few return fields. It omits critical context about pagination (cursor/offset), the 'raw' flag behavior, and the full structure of the response (which may include more than the listed fields). Given the lack of schema descriptions and output schema, the description is insufficient for reliable invocation and response interpretation.

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

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

Schema description coverage is 0%, and the description does not explain any of the five parameters. The phrase 'by name' implies the 'query' parameter, but there is no explanation of 'rows', 'cursor', 'offset', or 'raw'. The description fails to compensate for the lack of schema documentation, leaving the agent to infer parameter behavior.

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 ('Search') and resource ('funding bodies'), with a clear qualifier ('by name') and return fields. It distinguishes itself from sibling search tools by naming the entity type, and from 'get_funder' by being a search rather than a direct lookup.

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

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

No guidance is given on when to use this tool vs alternatives. It does not mention that 'get_funder' should be used to retrieve a specific funder by ID, nor does it explain when to use search_funders over other search_* tools. The only implied usage is that it searches by name, but no context or exclusions are provided.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, which covers the safety profile. The description adds the return field list but does not disclose pagination behavior, what 'raw' means, or any search limitations, which are relevant behavioral traits.

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 communicates the core action and return fields without waste. It is appropriately concise.

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

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

Given the tool has 5 optional parameters, no output schema, and no parameter descriptions, the description is too minimal. It lacks context about pagination options, row limits, and the raw flag, which are necessary for correct invocation.

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

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

Schema description coverage is 0% for the 5 parameters, and the description does not explain query, cursor, offset, rows, or raw. It only implies 'title/keyword' relates to the query parameter, which is insufficient compensation.

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 ('Search'), resource ('journals'), and search criteria ('title/keyword'), and lists the returned fields. This clearly distinguishes it from sibling tools like search_works and get_journal.

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

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

No guidance is provided on when to use this tool versus alternatives like search_works or get_journal. The description does not mention exclusions, prerequisites, or preferred use cases.

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 and open-world behavior, so the description needs only to add complementary context. It does so by stating what the search returns ('id + primary name'), which goes beyond the annotations. It does not detail pagination behavior or result ordering, but the return format disclosure is valuable and nonredundant.

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 conveys the core action and primary return field. Every word earns its place; there is no fluff or repetition. It is appropriately sized for a search tool.

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

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

Given the tool has 6 optional parameters and no output schema, the description is insufficiently complete. It does not explain how to construct a query, what filters are available, how pagination works, or the significance of 'raw'. It also does not mention the relationship to get_member for fetching full member details, leaving the agent without enough context to use the tool effectively in complex scenarios.

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 6 parameters with 0% description coverage, and the tool description provides zero explanation of what any parameter means. Terms like 'raw', 'filter', 'cursor', and 'offset' are left entirely to the agent's inference. The description does nothing to compensate for the schema's lack of documentation.

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

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

The description clearly states the tool's purpose: 'Search Crossref members (publishers/societies).' It uses a specific verb ('Search') and resource ('Crossref members'), and further clarifies scope with 'publishers/societies.' It also distinguishes from sibling search tools by naming the target entity type and explicitly stating the return shape ('id + primary name'), 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?

Usage is implied: this is the tool for searching Crossref members, as opposed to journals or funders. However, the description does not explicitly state when to prefer this over get_member, nor does it mention any exclusions or alternative tools. The guidance is present only through the resource name, not through direct recommendation.

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 openWorldHint=true, but the description adds substantial behavioral context not captured in annotations: simplified output unless raw=True, cursor-based paging with next_cursor, rows capped at 1000, and select for trimming payload. These are concrete expectations that go beyond the safety profile.

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 information-dense. It leads with a clear purpose, then proceeds through usage in logical order. Every line adds value—no filler or redundant phrasing. The multi-line bullet style improves scannability without being verbose.

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 12 parameters and no schema descriptions or output schema, the description covers the most critical aspects: query modes, filter syntax, pagination, payload trimming, and output format. It lacks explicit details on sort/order/offset and rate limits, but those are minor given the overall thoroughness.

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

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

Schema coverage is 0%, so the description carries the full burden for explaining parameters. It covers query, query_bibliographic/query_author/query_title, filter, rows, select, cursor, and raw with meaningful details. It omits sort, order, and offset, but these are relatively self-explanatory for a search API, so the description compensates well overall.

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 "Search Crossref works" which is a specific verb+resource pair, and it explicitly lists content types (articles, books, datasets). This clearly distinguishes it from siblings like search_members or search_journals, making the tool's purpose 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 detailed guidance on when to use different query modes (free-text vs field-scoped), filter syntax, rows cap, select, cursor, and raw. It does not explicitly name alternative tools for single-work lookup, but the context is clear enough that an agent would know to use this for searching works rather than get_work.

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