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

No annotations are provided, so the description carries the full burden. It discloses the source (CrossRef content negotiation) and the return shape, but says nothing about external network access, rate limits, failure behavior for unresolved DOIs, or the 200-item limit's consequences (though that is covered in the schema).

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

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

Two short sentences, front-loaded with purpose and then the return shape; no padding. It is terse enough that it borders on under-specification rather than excessive verbosity.

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?

An output schema exists, so explaining return values is not required (and the return note is mild redundancy). What is missing is guidance on selection among the annotate_dois_* siblings and any behavioral caveats for an external-lookup tool.

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

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

Schema description coverage is 100% and the single doi_list parameter is documented there, including the max-200 constraint. The description adds no syntax or format detail beyond the schema, 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?

States a concrete output and resource: BibTeX entries for DOIs, sourced via CrossRef content negotiation. That source detail helps separate it from annotate_dois_europmc, though it does not explicitly name siblings like annotate_dois_crossref, leaving some ambiguity in the annotate_dois_* family.

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 statement of when to choose this tool over annotate_dois_crossref or annotate_dois_europmc, and no prerequisites or conditions given. The agent must infer usage purely from the tool name and the parenthetical source.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it does not say whether this writes annotations back to pages, whether it requires auth/permissions, how missing DOIs are handled, or whether CrossRef rate limits apply. The mutation-vs-read nature of 'annotate' is left entirely ambiguous.

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?

One front-loaded sentence with zero filler; the source and verb lead, and the field list trails efficiently. It is appropriately sized, only slightly terse for a tool with unstated side effects.

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 annotations, no output schema, and undefined behavior on lookup failure, the description is not sufficient for an agent to predict side effects or downstream results. It explains what fields are fetched but not what the tool does to the corpus or what it returns.

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?

Single parameter with 100% schema coverage, so the schema already documents doi_list and its 200-item cap. The description's field list describes the output enrichment, not the parameter, so it adds no parameter meaning beyond the schema. 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?

States a specific verb (annotate), resource (DOIs), and the data source (CrossRef), then enumerates exactly which fields are added (title, authors, journal, year, publisher, type, is_referenced_by_count, url). The named source implicitly distinguishes it from the sibling annotate_dois_europmc and annotate_dois_bibtex, though it never explicitly contrasts them.

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

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

The 'through CrossRef' qualifier gives implicit routing guidance among the three DOI-annotation siblings, but there is no explicit when-to-use, when-not-to-use, or fallback if a DOI is absent from CrossRef. Usage is inferable from the source name alone.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses the output fields and the row-per-DOI shape, but says nothing about rate limits, error handling, or what happens to DOIs that resolve to no record — meaningful gaps for a network-backed annotation tool.

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, zero waste, front-loaded with purpose and output shape. Every clause 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?

There is no output schema, so the description's enumeration of returned fields (PMID/PMCID, title, authors, journal, year, citation_count, is_open_access) is valuable and largely fills that role. It stops short of explaining failure behavior for unresolved DOIs, which is the only notable gap.

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

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

Schema coverage is 100%, so the schema already documents the single parameter including the example DOI format and the max 200 limit. The description adds no parameter-level meaning beyond that, which is the expected baseline when the schema does the work.

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 (Annotate), resource (DOIs), and source (EuropePMC), plus the enrichment fields returned. The source name implicitly differentiates it from annotate_dois_crossref and annotate_dois_bibtex, but the description never makes that distinction explicit.

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

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

No when-to-use, when-not-to-use, or alternative-selection guidance is provided. The sibling list contains two direct competitors (annotate_dois_crossref, annotate_dois_bibtex), and the agent is given no signal for choosing among them.

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

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

With no annotations, the description carries the behavioral burden and discloses important operational traits: a small keyless quota, the GOOGLE_BOOKS_API_KEY environment variable, and HTTP 429 avoidance. It does not explicitly confirm read-only behavior, but it gives more rate-limit and auth context than typical descriptions.

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

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

Two compact sentences front-load what the tool returns and then add the quota/auth caveat plus the alternative. Every sentence earns its place with no redundant restatement of the schema or title.

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

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

The tool has a complete input schema, an output schema, and a clear description covering source, scope, rate-limit caveat, and alternative. An agent has enough information to select and invoke it correctly; return-value details are covered by the output schema.

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

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

Schema coverage is 100% and the single parameter is fully documented in the schema with ISBN-10/ISBN-13 format and hyphen allowance. The description adds only 'for one ISBN', so it does not go beyond the schema's own parameter 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 states a specific resource and source: 'Book metadata from Google Books for one ISBN.' It also names the sibling alternative (annotate_isbn_openlib), so an agent can distinguish this Google Books lookup from the OpenLibrary one without opening either schema.

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

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

It clearly indicates the context for using this tool and names an alternative: use annotate_isbn_openlib instead when the keyless quota is a problem. The guidance is conditional and practical, though it does not exhaustively state every when-not-to-use case beyond the quota/429 scenario.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses almost nothing beyond the data source. The verb 'annotate' implies enrichment or attachment of data, but the description never says whether anything is written, where results go, or whether external network calls or rate limits apply.

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 short fragment that is front-loaded with the source and scope. Nothing is wasted, though the fragmentary phrasing means it is terse to the point of omitting the verb.

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?

An output schema exists, so return values need not be described, and the single parameter is fully covered. What remains missing is behavioral context and routing versus annotate_isbn_google, leaving the definition only minimally viable for its sibling-rich environment.

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 single isbn parameter is already documented as accepting ISBN-10 or ISBN-13 with hyphens allowed. The description adds no format detail beyond the schema, so the baseline of 3 applies.

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

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

Names a specific resource (book metadata), a specific source (Open Library), and scoping (one ISBN), which lets an agent distinguish it from the sibling annotate_isbn_google. It lacks an explicit verb for what 'annotate' actually does, but the resource+source pairing is clear.

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

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

There is no guidance on when to prefer Open Library over the sibling annotate_isbn_google, nor any stated prerequisite or output condition. The agent must infer the choice purely from the source name embedded in the tool title.

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

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

No annotations are provided, so the description carries the full behavioral burden. It notes the target is the article's latest wikitext, but says nothing about return shape, whether results are aggregated per pattern, cost or rate limits, or how failures (e.g., missing article) are handled.

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 action first and supplies the pattern list as supporting detail. The parenthetical enumeration is information-dense rather than wasted, though it could be trimmed.

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 and no annotations, the description should explain what an agent receives back from a multi-pattern extraction. It omits return format entirely, leaving a meaningful gap for a tool whose whole value is the collection of extracted entities.

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

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

Schema description coverage is 100%, so lang, date_limit, and article_name are already documented in the schema. The description adds no parameter meaning beyond that, 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?

States a specific verb ('apply all built-in patterns') and a precise resource ('an article's latest wikitext'), and enumerates the seven patterns it covers. This distinguishes it from a custom-regex sibling, but it does not explicitly name or contrast with extract_with_regex or extract_citations.

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 'all built-in patterns' implicitly signals bulk extraction versus the single-pattern sibling extract_with_regex, but there is no explicit statement of when to prefer this tool, when not to, or what alternatives exist for narrower needs.

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

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

With no annotations, the description carries the full burden. It usefully implies the output is the raw matched templates rather than parsed citation objects, which is behaviorally meaningful against siblings. However, it discloses nothing about return structure, duplicate handling, malformed or nested templates, or failure behavior on non-wikitext input.

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

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

A single front-loaded sentence with zero filler. It is appropriately sized for the operation, though it is terse to the point of under-specification.

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?

As a pure function with no output schema and no annotations, the description must carry the full contract. It omits the shape of the return value, ordering, and behavior on inputs containing no citation templates, leaving real ambiguity for the agent.

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

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

Schema description coverage is 0% and the single parameter is named generically as 'text'. The description partially compensates by clarifying that the input is a wikitext string, which is the only semantic detail an agent needs here. It adds no information about expected formatting or encoding.

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 (Return/extract) and resource ({{cite ...}} templates) with scope (found in a wikitext string). It is clearly distinguishable from sibling tools like parse_citations or get_citation_types in that it returns raw templates rather than parsed metadata, though that contrast is never made explicit.

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

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

No guidance on when to use this tool versus parse_citations, parse_all_citations, extract_with_regex, or get_citation_types, all of which operate on similar inputs. The agent must infer the distinction from the name alone.

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

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

No annotations are provided, so the description carries the full burden. It does convey read-only behavior and the nature of the result ('Return every [[wikilink]] found'), but says nothing about output shape, ordering, duplicates, or how aliased/piped links are handled.

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

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

A single front-loaded sentence with no filler; the verb, the extracted pattern, and the input domain all appear immediately.

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 annotations and no output schema, the description should describe the return shape, but only says it returns every wikilink. Adequate for a trivial single-parameter extractor, but an agent still cannot predict the result format.

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?

One parameter with 0% schema description coverage, so the description must compensate. 'In a wikitext string' usefully clarifies that the input is wikitext markup rather than plain text, but adds no format or size constraints beyond that.

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 (Return/extract) and resource ([[wikilink]]s) plus the source domain (wikitext string), which is enough to tell it apart from replace_wikihypelinks and get_hyperlink_count. It does not explicitly name those siblings, so it falls short of a 5.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of the obvious alternative replace_wikihypelinks. The agent must infer the extraction-vs-replacement distinction from the name alone.

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

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

With no annotations, the description carries the full behavioral burden. It discloses only that it operates on the 'latest' wikitext (not full history), but says nothing about what is returned (matches vs. capture groups), behavior on zero matches, permissions, or rate limits.

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

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

A single front-loaded sentence with no filler or redundancy. It is efficient, though its brevity comes partly from under-specification rather than discipline.

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?

There is no output schema and no annotations, so the description must explain the return shape for a regex tool (match list, capture groups, no-match behavior). It does none of this, leaving a meaningful gap for a 4-parameter extraction tool.

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

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

Schema description coverage is 100%, so all four parameters (lang, regexp, date_limit, article_name) are already documented in the schema with defaults and constraints. The description adds no syntax, escaping, or date_limit interaction detail beyond that, 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?

States a specific verb (apply regex / extract) and a specific resource (an article's latest wikitext), which is clear and concrete. However, it offers no differentiation from the close sibling extract_all_regex, so an agent cannot tell them apart from the text alone.

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

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

There is no guidance on when to use this versus extract_all_regex or extract_citations, no prerequisites, and no exclusions. The agent must infer the distinction from names alone.

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

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

With no annotations, the description carries the full burden, and it does convey that this is a pure read-only computation returning a simple count. However, it adds little else: it does not state there are no side effects, whether the match is case-sensitive or multiline by default, or how the regex dialect/limits behave beyond what the schema already says.

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, front-loaded with the operation, and no wasted preamble. The second sentence's return shape is redundant given an output schema exists, but it costs little.

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 two-parameter pure function with full schema coverage and an output schema, the description covers the essentials. Only the positioning relative to the numerous regex/count siblings is missing, which is a minor but real gap.

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

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

Schema description coverage is 100%, so both text and regexp are already documented in the schema (including the 500-char limit and Python dialect). The description merely restates these at the same level of detail, adding no new semantics; 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 states a specific verb and resource: counting regex matches inside a text. It is unambiguous about the operation, but it never distinguishes itself from close siblings like extract_with_regex, extract_all_regex, or the many specific count tools (get_doi_count, get_ref_count, etc.), leaving the agent to infer the boundary.

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

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

There is no guidance on when to use this generic count versus the specialized counters or the extraction siblings. No prerequisites, no exclusions, no alternatives are named, so the agent must guess the intended scope.

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

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

No annotations are provided, so the description carries the full burden, and it does real work: it discloses the row-per-revision return shape, the exact field set, and the sort order ('oldest first'), plus what is deliberately absent (wikitext). It omits pagination/row-limit behavior and any size or rate constraints, which keeps it short of a 5.

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 tight sentences; the purpose comes first, then the return contract, then the exclusion/alternative. The field list is dense but every element earns its place since no output schema exists to carry it.

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 compensates by describing the result rows and sort order, and it names the alternative for wikitext. Minor gaps remain around result volume/pagination for long-lived articles and the precise semantics of the date_limit cutoff, but they are not required for a correct call.

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%: lang, date_limit (ISO 8601 upper bound) and article_name are all documented in the schema itself. The description adds no syntax, format, or default guidance beyond what the schema already states, so the baseline of 3 applies.

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

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

States a specific verb ('Retrieve') and resource ('full revision history of a Wikipedia article'), and the second sentence enumerates the exact per-revision fields returned. It also distinguishes itself from the sibling get_article_recent by noting wikitext exclusion, so the agent can route without opening a schema.

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

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

Gives a clear use condition implicitly (fetch revision history) and an explicit exclusion with an alternative: 'Wikitext is not included; use get_article_recent for that.' It does not, however, address how this differs from other similar siblings such as get_article_info or get_article_initial, leaving part of the routing to inference.

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

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

No annotations are provided, so the description carries full disclosure burden. It does contribute genuine behavioral context by stating that a non-existent page returns "missing": true, which is not derivable from the schema. It stops there, though: no indication of read-only semantics, auth requirements, or rate limits.

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 tight sentences with the returned fields front-loaded and the missing-page edge case last. No filler, no restatement of the title or name.

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

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

With an output schema present, the description need not enumerate return values, and it correctly focuses on scope plus the missing-page behavior. It covers enough for an agent to call the tool correctly, though it omits sibling differentiation that would make routing unambiguous.

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% (both lang and article_name are documented in the schema), and the description adds no parameter-level meaning beyond it. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

The description names a specific resource (current page metadata) and enumerates the exact fields returned (pageid, title, length, last revision id, touched timestamp), so the agent knows precisely what this fetches. It does not, however, distinguish itself from siblings like get_article_history, get_article_recent, or get_article_initial, which all touch the same resource.

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

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

There is no statement of when to use this tool versus the many article-related siblings, nor any prerequisites or exclusions. The agent must infer usage purely from the name and the field list.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses the shape of the returned payload, but says nothing about failure behavior (missing/renamed article, redirects), read-only nature, or whether wikitext can be large. Adequate but thin for a read tool with zero annotation support.

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

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

Two tight sentences that front-load the core action. The explicit return-shape sentence is mildly redundant given an output schema exists, but it is short and not wasteful.

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 two-parameter read tool with an output schema and full schema coverage, the description is largely sufficient. The remaining gaps (error/redirect handling, size expectations) are minor rather than blocking.

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

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

Schema description coverage is 100%, with both lang and article_name already documented (including the "en" default), so the schema does the heavy lifting. The description adds no parameter syntax, format, or edge-case guidance 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?

States a specific verb (Retrieve) and resource (first/creation revision of an article) and adds "with its wikitext", which cleanly separates it from siblings like get_article_history, get_article_recent, and get_article_info. An agent can identify the exact revision scope without opening the schema.

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

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

The phrase "first (creation) revision" implies when this tool is appropriate versus the history/recent siblings, but no alternative is named and no explicit when-to-use or when-not guidance is given. Usage must be inferred from the scope wording.

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses the inclusive date bound and the return shape (metadata + full wikitext), and 'Retrieve' implies a read operation, but it says nothing about permissions, rate limits, or behavior when no revision exists at/before the date.

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 tight sentences with the scope and result front-loaded and no filler. The trailing return-shape clause is slightly redundant since an output schema exists, but it is brief and harmless.

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?

A read tool with a full output schema and 100% parameter coverage needs only light prose, which this supplies. The main gap is the absence of any pointer to sibling tools (initial/history) that an agent would need to pick the right one.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters, making the baseline 3. The description adds only marginal meaning by restating the inclusive upper-bound semantics of date_limit ('at or before'), which the schema already conveys as 'Upper date bound'.

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 (Retrieve) and resource (latest revision of an article) with an added scope constraint (at or before date_limit). An agent can infer it differs from get_article_initial and get_article_history, though the description never names those siblings explicitly, so differentiation is implied rather than stated.

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 'latest revision ... at or before date_limit' implies when the tool is appropriate (getting the most recent version bounded by a date), but there is no explicit when-to-use, when-not-to-use, or named alternative. Usage must be inferred from the scope wording.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read operation but does not state the return shape, whether lookups fail silently for missing articles, or any batch/rate constraints beyond the schema's max-100 note.

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

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

A single front-loaded sentence with the key qualifier '(first revision)' inline; there is no filler or redundancy. It is terse but appropriately sized for a two-parameter tool.

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

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

With no output schema and no annotations, the description must explain what 'creation metadata' actually contains and what a caller gets back. It stops at the concept and never describes the return payload, which is a meaningful gap for a metadata-returning tool.

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

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

Schema description coverage is 100%, so the schema already documents both article_list and lang, making 3 the baseline. The description adds nothing about parameter behavior (e.g., how missing or redirected titles are handled, or language fallback), so it does not exceed 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 names a concrete resource ('Creation (first revision) metadata') and a target ('a list of articles'), which is more than a restatement of the title. However, it gives no way to distinguish this from close siblings like get_article_initial or get_article_history, and the name's 'category' framing conflicts with the article-oriented description, leaving the actual scope ambiguous.

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

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

There is no guidance on when to use this tool versus get_article_initial, get_article_history, or get_article_info, all of which plausibly return related per-article metadata. No prerequisites, no exclusions, no context beyond the bare purpose.

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

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

No annotations are provided, so the description carries the full behavioral burden and mostly fails it. 'Concatenated' hints at output shape but is unexplained, and there is no mention of truncation limits, ordering, output size, or whether responses can be huge given up to 100 articles.

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?

It is a single, front-loaded sentence with no filler. Brevity is achieved cleanly, though the sentence is arguably too thin to justify the tool's complexity rather than padded.

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 annotations, no output schema, and a multi-item input that produces a concatenated history payload, the description should explain the output format, limits, and its relationship to get_article_history. None of that is present, so an agent cannot confidently choose or call this tool.

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

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

Schema description coverage is 100%, so both parameters (lang with its default, article_list with max 100) are already documented in the schema. The description adds no syntax, format, or semantics beyond that, 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 names a verb (retrieves) and resource (full revision history) for a list of articles, which is broadly understandable. However, the tool is named get_category_history yet the description mentions no category parameter or category scope, and it does not distinguish itself from the sibling get_article_history — leaving the actual scope ('concatenated' list vs single article) ambiguous.

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

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

There is no when-to-use guidance and no indication of how this differs from get_article_history or get_article_recent, despite many closely related history siblings. The agent is left to guess which history tool applies.

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

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

With no annotations, the description carries the full burden. It usefully discloses two behavioral scoping traits – namespace 0 only and direct membership (no subcategory recursion) – but says nothing about pagination, result limits, ordering, or whether redirects/non-article pages are excluded.

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 phrase with zero filler; the two scoping constraints are the first things read. It is arguably too terse rather than too long, but 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 two-parameter read tool with no output schema and no annotations, the description covers the core return semantics (titles) and scope, but leaves output format, ordering, and sibling selection unaddressed, which is a modest but real gap.

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

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

Schema description coverage is 100%: both 'lang' and 'category' are documented in the schema, including the 'Category:' prefix handling. The description adds no parameter-level information beyond what the schema already provides, so the baseline of 3 applies.

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

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

States the specific resource (article titles) and two important scoping constraints: namespace 0 and 'directly in a category' (non-recursive). This distinguishes it from the subcategory siblings (get_subcat_table, get_subcat_with_depth), but it never names or contrasts with the closest siblings get_pages_in_cat_table or get_page_in_cat_multiple, so an agent must infer the boundary.

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

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

There is no explicit when-to-use, when-not, or alternative named. The word 'directly' implies non-recursive traversal, which is a weak usage hint, but nothing tells the agent when to pick this over get_pages_in_cat_table or get_page_in_cat_multiple.

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

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

No annotations are provided, so the description carries the full burden. It does disclose the result shape (parallel metadata and wikitext arrays) and an ordering guarantee ('in input order'), which is genuinely useful behavioral context, but it says nothing about permissions, batching limits, failure behavior when a title is missing, or cost for large lists.

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, front-loaded with the core purpose and followed by the return shape. Nothing is padded, though the second sentence partially duplicates what the output schema already declares.

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?

An output schema exists, so the description need not explain return values, freeing it to cover routing and behavior. It does not, and the name/description mismatch (category vs. article list) plus absent usage guidance leaves the agent with real gaps for a tool that competes with many similar siblings.

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

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

Schema description coverage is 100%, so lang, date_limit, and article_list are already documented in the schema, including the max-100 cap and ISO 8601 format. The description adds no parameter meaning beyond that, 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 gives a clear verb+resource (fetch latest revision metadata and wikitext for a list of articles), but it conflicts with the tool name: 'get_category_recent' implies category-scoped retrieval while the schema and description operate on a flat article_list. With near-identical siblings like get_article_recent and get_article_history, an agent cannot tell what uniquely selects this tool.

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

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

No when-to-use guidance is given, and no alternative is named. The description never explains when to prefer this over get_article_recent, get_article_info, or get_category_pages, which is exactly the ambiguity that matters given the crowded sibling set.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses only that it counts templates by canonical type, without explaining return format, whether date_limit affects results, auth needs, rate limits, or how canonicalization is determined.

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 operation and key output dimension without waste. The parenthetical examples add useful precision without bloat.

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 a simple count operation with full schema coverage and no annotations or output schema, the description is adequate to understand what it does. It leaves gaps around return structure and how date_limit affects counts, but those are minor for this tool type.

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

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

Schema description coverage is 100%, so all three parameters are already documented in the schema. The description adds no parameter-level detail beyond what the schema provides; baseline 3 is appropriate.

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

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

States a specific verb ('Count') and resource ('citation templates by canonical type') for an article. The examples (journal, book, web, news) clarify what 'canonical type' means. However, it does not explicitly distinguish itself from siblings like get_ref_count or get_source_type_counts, so an agent might still hesitate between them.

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

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

Provides no explicit when-to-use or when-not-to-use guidance. It implies a use case ('for an article') but never states conditions for selecting this tool over alternatives such as get_ref_count or get_source_type_counts.

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses the output shape ({"count": n}), but says nothing about whether the operation is pure/read-only, whether auth or rate limits apply, or how malformed input is handled. For a stateless count function the risk is low, so 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?

Two short sentences, purpose front-loaded, output shape stated tersely. 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?

An output schema exists, so the description needn't document return values, and for a one-param pure count tool the definition is nearly complete. A note on edge cases (empty string, non-DOI text) would round it out, but 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 0% with a single unnamed-prose 'text' param. The description compensates slightly by revealing the input should be a wikitext string, which is real signal beyond the schema's bare 'string' type, but it adds no format or syntax guidance.

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?

Specific verb (Count) and resource (DOIs) with the input type named (wikitext string), which distinguishes it from the sibling count tools like get_isbn_count and get_url_count by the resource it targets. It does not explicitly contrast itself with those siblings, but the resource is precise enough that an agent can route correctly.

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 states only what the tool does. It never says when to reach for this versus get_any_count or the other count/extraction siblings, and offers no exclusions or preconditions.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses almost nothing: no mention of counting semantics (unique vs total, nested links, duplicates, malformed brackets) or edge cases. The one returned line, {"count": n}, merely restates what the existing output schema already defines, so it adds no behavioral value.

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, front-loaded with the operation and target, with zero filler. 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?

An output schema exists, so the return structure need not be explained (and the description's echo of it is redundant). For a one-parameter counting utility this is nearly complete, though edge-case counting behavior would be worth a clause.

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% and the single 'text' parameter is only typed as a string in the schema, but the description usefully constrains the expected input format to wikitext markup containing [[wikilinks]], which is real meaning beyond the schema. It does not, however, clarify how the parameter is scoped or validated.

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 precise verb and resource: count [[wikilinks]] in a wikitext string. This distinguishes it from sibling counters like get_url_count, get_ref_count, get_doi_count and get_isbn_count by naming the exact target syntax, though it doesn't explicitly compare itself to extract_wikihypelinks, which is the closest functional neighbor.

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

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

There is no statement of when to use this tool versus the many sibling count/extract tools, and no prerequisites or exclusions. The agent must infer usage entirely from the name and target syntax.

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

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

No annotations are provided, so the description carries the full behavioral burden. It notes the return shape, but with an output schema already present that adds little, and it says nothing about what qualifies as an ISBN (ISBN-10 vs ISBN-13, validity checks, duplicates, template/markup handling) or about failure behavior on empty input.

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, front-loaded with the action and immediately followed by the return shape. No filler and nothing that could be trimmed.

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 one-parameter counter with an output schema, the definition covers the essentials, but the missing matching semantics (which ISBN formats are recognized, whether duplicates are collapsed) leave an agent unable to predict edge-case results.

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 single 'text' parameter, so the description must compensate. Saying the string is wikitext does narrow the expected input format, but it gives no detail on how ISBNs are expected to appear, so the compensation is only partial.

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 (Count) plus resource (ISBNs) and input type (wikitext string), which cleanly separates it from the sibling counting tools like get_doi_count, get_ref_count, and get_url_count. It stops short of explicit sibling differentiation within the text, so it is clear but not maximal.

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 when-to-use context, no prerequisites, and no mention of alternatives despite many near-identical sibling counters (get_any_count, get_doi_count, etc.). The intended usage can be inferred from the resource name but is never 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?

No annotations are provided, so the description carries the full disclosure burden. It reveals one behavioral trait (result rows are tagged with source_category), but omits read/write nature, permissions, pagination, result size, and error behavior.

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

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

Extremely short and front-loaded; the resource and scope lead. It is a fragment rather than a full sentence, but nothing is wasted and no padding 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?

With no annotations and no output schema, the description should explain output shape and behavior more fully. It mentions only the source_category column and omits result format, ordering, and size expectations, so an agent cannot call it confidently without inspecting 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 100%, with both lang and catname_list fully documented (including the max-20 limit), so the schema does the heavy lifting. The description adds no parameter meaning beyond the schema, which is the baseline 3 case.

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 what is returned (pages) and the scope (several categories), with a useful note that rows carry source_category. However, it does not distinguish this tool from very similar siblings such as get_pages_in_cat_table, get_category_pages, or get_subcat_multiple, leaving the agent to guess which multi/single-category variant applies.

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

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

There is no statement of when to use this tool versus alternatives, nor any prerequisites or exclusions. Given the crowded family of category-listing tools, the absence of routing guidance is a real gap.

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

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

No annotations exist, so the description carries the full burden. It usefully discloses the output columns (pageid, ns, title, type) and implies a non-recursive read via 'directly', but says nothing about pagination, result limits, or whether the operation has any side effects.

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 puts the resource and scope first and the output shape in parentheses. No filler, nothing redundant.

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 column list is valuable compensation and the tool is a simple read, so an agent has most of what it needs. Pagination behavior and the precise distinction from the non-table sibling remain unaddressed.

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

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

Schema coverage is 100% – both lang and category are already documented in the schema, so the schema does the heavy lifting. The description adds no format or syntax detail beyond it, matching the baseline for full 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 (get), resource (pages), scope (directly in a category) and output form (table with named columns). It implicitly separates itself from subcategory siblings like get_subcat_table and depth tools, but never names an alternative explicitly.

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 word 'directly' hints that this is non-recursive, which is the main selection axis against get_subcat_with_depth or get_subcat_table, but no when-to-use or when-not-to-use condition is stated. Usage must be inferred from the scope word alone.

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

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

No annotations are provided, so the description carries the burden, but for a pure counting function that burden is small. It discloses the return shape, which is redundant with the existing output schema, and does not clarify edge cases such as self-closing, named, or nested <ref> tags.

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 zero filler, and the core action is front-loaded. Every clause 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 single-parameter counting tool with an output schema already present, the description covers the essentials and need not restate return values. The only real gap is what syntactic forms of <ref> are counted.

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 parameter name 'text' is bare. The description adds real meaning by specifying it must be a wikitext string, but it does not address format expectations or whether the whole string is scanned versus a fragment.

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+resource: counting <ref> tags within a wikitext string. This clearly separates it from generic siblings like get_any_count or get_doi_count, though it never names those siblings to reinforce the distinction.

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 when-to-use guidance, no prerequisites, and no mention of when a sibling such as get_any_count or extract_with_regex would be preferable. The agent must infer the use case from the name alone.

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

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

With no annotations, the description carries the full burden and does disclose non-obvious behavior: result ordering, a hard data-availability limit (~30 days of recent changes), and a latency warning ('can take a minute or more'). It omits auth/permission requirements and whether counts are of edits or editors, so it falls short of exhaustive.

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 tight paragraphs, zero filler. The core purpose and ordering are front-loaded, and the caveats follow in a clearly subordinate second paragraph.

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?

There is no output schema, so the description should ideally sketch the return shape; 'per article ... most reverted first' implies a ranked list but never states what fields come back (article title, count?). Given the tool's simplicity and the strong coverage of limitations and latency, it is nearly complete.

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

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

Schema description coverage is 100% and all three date/lang parameters document their defaults and formats, so the schema does the heavy lifting. The description only adds the consequence of choosing an old window, not syntax or format detail 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?

States a specific verb+resource (revert-tagged edits per article), the scope (date window), the tagging mechanism (mw-reverted, mw-undo, mw-rollback), and the result ordering (most reverted first). No sibling tool in the list covers reverts, so an agent can route to it unambiguously.

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 30-day retention note effectively tells the agent when the tool is and is not useful ('older windows return partial or empty results'), which is real usage guidance. It does not name alternatives, but no sibling covers revert data, so the gap is minor.

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

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

With no annotations, the description carries the full behavioral burden, and it does disclose the metric's formula, its 0-1 range, and the returned keys. However, it says nothing about permissions, rate limits, failure behavior, or whether date_limit materially changes the score. The metric definition is genuinely useful context, but operational traits are absent.

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 tight sentences with the metric definition front-loaded and the return payload following. Every element is short and nothing is padded. The return-key listing is mildly redundant against the output schema, but it costs little.

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 3-parameter read tool with full schema coverage and an output schema, the essential missing piece is the meaning of the score itself, which the description supplies. Since an output schema exists, the return values would not strictly need restating, and no operational caveats are missing that would block 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 100%, so lang, date_limit, and article_name are all documented in the schema. The description adds no parameter-level meaning beyond what the schema provides, 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 states a specific computed metric (SciScore) with its exact definition — the fraction of an article's citation templates that cite journals, scaled 0-1. This is a clear verb-implied resource and clearly differentiates from siblings like get_ref_count or get_doi_count, which count raw items rather than compute a ratio. It stops short of explicitly naming when it differs from those siblings, but the metric definition itself 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?

There is no guidance on when to use this tool versus alternatives such as get_citation_types or get_source_type_counts, which operate on overlapping citation data. No prerequisites, exclusions, or context for choosing it are provided. The agent must infer usage entirely from the metric name.

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

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

With no annotations provided, the description carries the full behavioral burden. 'Count ... in a raw wikitext string' strongly implies a pure, side-effect-free computation on an already-fetched string (no network, no mutation), which is meaningful signal. However, it never states the return shape (a type-to-count mapping) or whether unknown/uncanonical templates are included, so it stops short of real 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?

A single front-loaded sentence with the action first, no filler, and no redundancy with the title. Nothing is wasted, though the brevity is partly the source of the coverage gaps noted elsewhere.

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?

There is no output schema and no annotations, so the description is the only place an agent could learn the return format and the meaning of 'canonical type'. It omits both, which is a real gap for a counting tool whose entire value is in the shape of its result. Parameters are fully covered by the schema, so it is minimally adequate but not complete.

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

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

Schema description coverage is 100%, so both 'text' and 'lang' are already documented including the default. The description adds no syntax, format, or edge-case detail beyond the schema, 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?

States a specific verb ('Count'), resource ('citation templates'), and dimension ('by canonical type') plus the input ('raw wikitext string'). It is unambiguous on its own, but it makes no effort to distinguish itself from close siblings like get_citation_types, get_any_count, or get_ref_count, which an agent would have to open schemas to disambiguate.

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 when-to-use guidance, no preconditions, and no alternatives named. In a crowded family of counting/parsing siblings, the description provides no routing information, leaving the agent to guess between get_source_type_counts, get_citation_types, and get_any_count.

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

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

No annotations are provided, so the description carries the full burden. It hints at output structure ('rows carry source_category') and that only direct children are returned, but says nothing about permissions, limits (the schema caps at 20), pagination, or return format for a tool with no output schema.

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

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

A single front-loaded sentence with no filler. It is terse rather than verbose, though the brevity comes at the cost of under-specification rather than trimming waste.

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 multi-category lookup tool with no output schema and no annotations, the description is thin: it does not describe the return shape beyond one field, nor limits or ordering. An agent cannot fully predict what it will receive.

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% — lang and catname_list are fully documented in the schema, including the max-20 constraint. The description adds nothing beyond the schema, so the baseline of 3 applies.

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

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

States a specific verb and resource (subcategories) with batch scope ('several categories'), and the parenthetical clarifies output shape. It does not explicitly distinguish itself from siblings like get_subcat_table or get_subcat_with_depth, leaving the agent to infer the difference.

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

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

There is no when-to-use guidance, no prerequisites, and no named alternatives. The agent gets no help deciding between this, get_subcat_table, and get_subcat_with_depth.

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

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

No annotations are provided, so the description bears the full burden of behavioral disclosure. It reveals nothing about read-only safety, permissions, return structure, pagination, or how the 'table' is formatted, making it effectively silent on behavior.

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

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

The description is a single five-word fragment, which is not verbose but is severely underspecified for a tool with three parameters and a table output. It is front-loaded but fails to earn its brevity by omitting necessary context.

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 no annotations, no output schema, and a table-returning operation, the description is incomplete: it does not explain what the table contains, what 'direct' means operationally, or how results relate to sibling tools. The agent lacks enough context to invoke it confidently.

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

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

Schema description coverage is 100%, and all three parameters (lang, catname, replacement) are documented in the schema. The description adds no parameter-level meaning, so the baseline of 3 applies.

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

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

The description states the resource and scope ('direct subcategories of a category') but gives no verb and does not mention output format (e.g., a table). It hints at differentiation from depth-based siblings via 'direct', but does not name any alternative. This is a vague fragment rather than a clear action statement.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternative tools such as get_subcat_multiple or get_subcat_with_depth. The description leaves the agent to infer everything from the name and 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?

No annotations are provided, so the description carries the full behavioral burden. It discloses recursion and the depth ceiling (1-5), but says nothing about read-only nature, cost/performance of deep recursion, output shape, or failure behavior for missing categories.

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

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

A single front-loaded sentence with no filler, and the recursion constraint leads. It is efficient, though its brevity borders on under-specification rather than tightness.

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 annotations and no output schema, the description is the only place return shape, read-only semantics, and the effect of lang/replacement could be explained, and it covers none of them. For a four-parameter recursive traversal tool this leaves meaningful 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 coverage is 100%, so all four parameters (lang, depth, catname, replacement) are already documented in the schema. The description restates only the depth range, adding no syntax or format meaning beyond what the schema provides, 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?

States a specific verb (collect) and resource (subcategories) plus the distinguishing recursion trait, so the agent knows it walks a category tree rather than returning a flat list. However, it never distinguishes itself from siblings like get_subcat_table or get_subcat_multiple, so an agent must guess which subcategory tool applies.

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

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

There is no when-to-use guidance, no mention of alternatives, and no prerequisites (e.g., that a valid catname and language wiki must exist). The only implicit signal is the recursion semantics.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only lists return keys and does not state that this is a read-only operation, whether it has side effects, authentication requirements, rate limits, or how large the history payload might be.

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 with zero waste. It is front-loaded with the key value proposition ('in one call') and then concisely lists the returned keys. 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?

With a complete input schema and an output schema present, the description does not need to explain parameters or return values in detail. It states what is aggregated and the top-level return keys. The main gap is the absence of any behavioral context for a no-annotation tool and the unexplained 'tables' in the tool name.

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

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

Schema description coverage is 100%, so all parameters (lang, date_limit, article_name) are already well documented in the schema. The description adds no parameter semantics beyond what the schema provides, so the baseline score of 3 is appropriate.

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

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

The description states the specific contents returned (info, initial revision, latest revision, full history) and emphasizes consolidation into one call. It implicitly distinguishes itself from the sibling get_article_info/initial/recent/history tools by listing those same components. However, it never states the resource type ('article' or 'tables'), and the tool name's 'tables' remains unexplained.

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 'in one call' implies the intended use case: retrieving all four pieces of data together rather than making separate calls. No explicit alternatives are named, and there is no guidance on when not to use it (e.g., if only info or only history is needed).

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

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

With no annotations, the description carries the full burden. It usefully discloses the 40-item cap, the ordering (ranked by citation count, called wiki_count) and that entries are annotated via EuropePMC, but it omits what happens when the article is missing, whether results are cached, and what fields the annotated DOIs carry.

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 dense sentence with the scope ('up to 40 most-cited DOIs in an article') front-loaded before the annotation and ranking details. No filler, though the parenthetical '(wiki_count)' is a somewhat opaque internal term.

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?

There is no output schema and no annotations, so the description must explain the return shape, and it only partially does (DOIs annotated via EuropePMC, ranked by wiki_count). It is minimally sufficient but leaves the response structure and error behavior unspecified for a tool whose output is the whole point.

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

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

Schema description coverage is 100%, so lang, date_limit and article_name are all documented in the schema itself. The description adds nothing about how lang or date_limit affect the ranking or which citations are considered, 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 names a specific resource (the most-cited DOIs within a single article), quantifies the scope (up to 40) and states the ranking metric. It is clear what the tool returns, but it never distinguishes itself from adjacent siblings such as get_doi_count or annotate_dois_europmc, which an agent could easily confuse it with.

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

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

There is no when-to-use guidance, no prerequisites (e.g. the article must exist / be a valid Wikipedia title), and no mention of alternatives. The reader must infer from the name alone that this is the 'top cited' variant rather than a plain count or a generic annotation 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?

No annotations exist, so the description carries the full burden, but this is a pure, side-effect-free counting function where little disclosure is required. It does reveal the output shape ({"count": n}), though it says nothing about edge cases such as what syntactic forms qualify as an http(s) URL.

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, front-loaded sentences with zero filler. The return-value sentence is slightly redundant given an output schema exists, but it is brief enough not to hurt.

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 trivial one-parameter pure function the coverage is close to sufficient, and the output schema already documents the return value. It still lacks the URL-counting semantics (what qualifies) and any routing versus get_hyperlink_count, so gaps remain.

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

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

Schema coverage is 0%, so the description must compensate. It clarifies that the single 'text' parameter is expected to be a wikitext string, which adds genuine meaning over the bare schema, but adds no format, size, or encoding detail beyond that.

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 (count) and resource (http(s) URLs) plus the scope (a wikitext string), so an agent knows exactly what it computes. However, it does not differentiate from the adjacent sibling get_hyperlink_count, which an agent could easily confuse with URL counting.

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

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

There is no when-to-use guidance, no named alternative, and no exclusions. With a large sibling family of similarly named count tools (get_doi_count, get_ref_count, get_isbn_count, get_hyperlink_count), the agent is left to infer selection entirely on its own.

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

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

With no annotations, the description carries the full behavioral burden and falls short. It conveys the output row shape, which is genuinely useful, but says nothing about scope (does it parse entire article or a section?), failure modes for missing templates, or limits.

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 compact sentence with no filler. Because no output schema exists, spending the sentence on the return shape is reasonable, though front-loading the tool's action would have been stronger.

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?

No output schema exists, so the description's return-format note partially fills that gap, but the absence of any purpose/usage guidance for a 3-parameter parsing tool leaves it only partially complete.

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

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

Schema description coverage is 100%, so lang, date_limit, and article_name are already documented in the schema. The description adds no parameter-level meaning, 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 describes the output shape (a long-form table with variable/value/canonical_field rows) but never states the action explicitly or distinguishes this tool from close siblings like parse_citations, extract_citations, or parse_cite_type. An agent can roughly infer it parses citations, but the core 'what' is implied rather than stated.

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

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

There is no guidance on when to use this versus the many sibling parsing tools. No conditions, prerequisites, or exclusions are provided, leaving the agent to guess.

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

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

With no annotations, the description carries the full burden. It does disclose one real behavioral trait — native template support for en/fr/de/es/it/pt Wikipedias — but omits what happens for unsupported languages, how non-template (plain-text) citations are handled, whether the operation is read-only, error behavior, or any result-size considerations.

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 compact sentences with no filler, and the returned-field inventory is front-loaded where an agent will see it first. The only inefficiency is that the opening is a noun phrase rather than an action statement.

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?

Since there is no output schema, the description correctly compensates by enumerating the return columns. What it lacks is disambiguation from parse_all_citations/extract_citations and any statement about failure modes for unsupported languages, which leaves a real ambiguity for an agent choosing among siblings.

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

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

Schema description coverage is 100%, so the three parameters (lang, date_limit, article_name) are already documented. The description adds nothing about parameter semantics — the field list describes return columns, not inputs — 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 specifies the output shape precisely (one row per citation template, listing doi/isbn/pmid/url/title/author/year/journal/publisher/accessdate), which implies extraction of citations from a Wikipedia article. However, it never states the action with a verb — 'Structured citation table' is a noun phrase relying on the tool name — and it does not distinguish itself from close siblings such as parse_all_citations, extract_citations, or get_citation_types.

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

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

There is no when-to-use guidance, no exclusions, and no reference to any of the many sibling tools. An agent reading this cannot tell why it should call parse_citations rather than parse_all_citations or extract_citations — a significant gap given the dense sibling set.

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

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

No annotations, so the description carries the full burden. It usefully discloses output behavior – returns a cite_type/fields object, or {} when no template is found, which is meaningful fallback detail. However it says nothing about the nature of the operation (purity/side effects) or what 'fields' contains.

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 tight sentences, front-loaded with the action and followed by the return contract. No filler, though it is quite terse given the gaps left elsewhere.

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?

An output schema exists, so return values needn't be re-explained (the description restates them anyway). For a simple single-param parser this is nearly complete; the missing piece is routing guidance relative to the many citation siblings.

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

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

With 0% schema coverage and one parameter, the description must compensate. It does add meaning by indicating the input is a single '{{cite ...}}' template string, showing the expected format. It still leaves open whether outer braces/delimiters must be included, so compensation is partial.

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 ('Parse') and resource ('one {{cite ...}} template string'). The 'one' singular scope implicitly differentiates it from siblings like parse_citations and parse_all_citations, though it doesn't name them explicitly.

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 'one' and '{{cite ...}}' phrasing implies the input type and scope, but there is no explicit when-to-use guidance or exclusion versus parse_citations, parse_all_citations, or get_citation_types. Usage is inferred 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?

With no annotations present, the description must carry the behavioral burden; it does disclose the return payload ('Returns {"cleaned_text": "..."}'), which is useful. However, it says nothing about handling of malformed/nested/escaped wikilinks, idempotency, or whether the operation is non-destructive, so transparency is only partial.

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, front-loaded with the transformation rule and trailing the return shape. No filler; every clause 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 low-complexity, single-parameter string transform with an output schema present, the description covers the transformation and the return key, which is sufficient to invoke it. Minor gaps remain around input edge cases, but nothing blocks correct usage.

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 one parameter with 0% schema description coverage, so the description should compensate. The examples implicitly communicate the expected input domain (wikitext containing [[...]] links), but the sole 'text' parameter is never named or described, leaving the mapping inferred rather than stated.

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+resource and pins it down with a literal before/after example ('Replace [[Target|Label]] with Label and [[Target]] with Target'), so the exact transformation is unambiguous. The 'replace' verb cleanly separates it from the 'extract_wikihypelinks' sibling, which shares the same resource but a different action.

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 explains what happens but never says when to reach for this tool versus extract_wikihypelinks or the other citation/regex extractors in the sibling list. No prerequisites, exclusions, or context of use are given.

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