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

Annotations already cover the safety profile with readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the bar for the description is lower. The description adds genuine behavioral context beyond annotations: the tool performs validation (it can reject malformed input) and makes no network request, implying no rate-limit, auth, or latency concerns. There is no contradiction with the annotations.

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

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

A single 21-word sentence that front-loads the action and resource, enumerates the input condition types, and closes with the key no-network constraint. Every phrase carries information and there is zero filler or redundancy.

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

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

The output schema covers the return shape, the 100% schema coverage documents all five optional parameters, and the four annotations establish the safety profile. The description adds the validation behavior and offline nature, leaving only minor gaps such as explicit failure semantics and the unstated-but-implied intent that the generated query feeds a subsequent search 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%, with each parameter already documented (e.g., 'Up to 10 tags that results must exclude', 'Up to 10 tags combined as an OR condition'), so the baseline is 3. The description groups the parameters into condition categories (include, exclude, OR, exact-tag, title), which frames their roles holistically, but it adds no detail beyond what the schema already provides.

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

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

The description states a specific verb ('build and validate') against a specific resource ('native search syntax'), and enumerates the exact condition types it composes: include, exclude, OR, exact-tag, and title. The clause 'without making a network request' sharply distinguishes this offline query builder from the 28 sibling search and query tools, so an agent can tell it apart without inspecting schemas.

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 'without making a network request' clause implies an offline, preparation-oriented use case — constructing and pre-validating a query before a search is executed. However, the description never explicitly names an alternative, states when-not-to-use it, or tells the agent to pass the result into a sibling like eh_search_galleries, leaving 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds useful behavioral context by specifying exactly which access-related states are diagnosed (reachability, auth state, Cloudflare challenge), going beyond the annotations without contradicting them.

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

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

A single sentence that front-loads the action ('Diagnose') and then lists the three diagnostic domains. Every word contributes to understanding the tool's purpose, with no filler or repetition.

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

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

For a simple, optional-parameter, read-only diagnostic tool with rich annotations, the description is nearly complete. The only notable gap is that it does not describe the return format or result structure, but the tool's purpose and safety profile are clear enough for an agent to select and invoke it correctly.

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

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

Schema description coverage is 100%: the 'site' parameter is fully documented with an enum and a clear description. The tool description itself adds no additional parameter meaning, which matches the baseline for a fully covered simple schema. Minor note: the schema's mention of 'URL override' does not correspond to any visible URL parameter.

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

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

The description immediately identifies the tool as a diagnostic action ('Diagnose') with a specific resource scope: reachability, authentication state, and Cloudflare challenge state for E-Hentai or ExHentai. This clearly distinguishes it from the sibling gallery/favorite/search tools, which are all data-retrieval or management operations.

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

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

The description implies the tool is for diagnosing access issues but provides no explicit guidance on when to choose it over sibling tools or when not to use it. There is no mention of alternative tools or conditions that would make another tool more appropriate.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, covering the safety and network profile. The description adds genuine behavioral content beyond that: it discloses the specific diff surface (metadata fields plus namespaced tag additions/removals), which tells the agent what the operation actually computes. It omits rate-limit or auth context, but the safety profile is already covered.

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. The verb and resource lead, and the comparison dimensions follow immediately, so the agent gets the essential information first.

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, return values need not be described, and annotations carry the safety profile. The description is sufficient to invoke the tool correctly against a fully documented schema. The remaining gap is routing guidance relative to version-related siblings, which keeps it from a 5.

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 before/after nested objects documented (gid constraints, token pattern) and the site enum explained including URL-override behavior. The description mentions 'two gallery versions' generically but adds no syntax or format detail beyond the schema, so the 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 ('Compare'), resource ('two gallery versions'), and enumerates the exact dimensions compared (title, posted time, page count, file size, tag additions/removals). This makes the tool's function unambiguous. It stops short of naming or distinguishing itself from adjacent siblings like eh_find_latest_gallery_version or eh_get_gallery_chain, so it lands at 4 rather than 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?

The description contains no when-to-use guidance, no prerequisites, and no reference to alternatives. An agent cannot infer from the text whether this should be preferred over eh_get_gallery_chain or how the 'before'/'after' pair should be sourced. Only implied usage is present.

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

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

Annotations already declare readOnly, idempotent, non-destructive and openWorld, so the safety profile is covered. The description adds genuinely useful failure context — invalid references, deleted galleries, auth failures, challenge pages, and upstream errors surface as tool errors — which an agent needs to handle outcomes.

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: the core action is front-loaded, the routing alternative follows, and the error contract closes it out. Every sentence earns its place.

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

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

Covers purpose, sibling routing, and error modes, while an output schema exists so return values need not be explained. Nothing an agent needs to call this correctly is missing.

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

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

Schema description coverage is 100%, with clear docs including the mutually-exclusive gallery vs galleryUrl constraint, so the schema carries parameter meaning. The description adds no additional parameter semantics, making the baseline 3 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 and resource: resolve a gallery's version chain and return the latest semantic version. It explicitly distinguishes itself from eh_get_gallery_chain, the closest sibling, so an agent can route correctly without inspecting schemas.

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 both the when-to-use-this (need only the latest semver) and the explicit alternative with its selecting condition ('Use eh_get_gallery_chain when the complete ordered chain is needed'). Nothing is left to inference.

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

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

Annotations already cover the safety profile (readOnly, idempotent, openWorld, non-destructive), so the bar is lower. The description adds real behavioral value by disclosing the internal fallback chain: structural title extraction, then exact quoted search, then artist tag, then uploader. It does not mention whether the source gallery appears in results or how many results are returned.

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 that front-loads the purpose and then the mechanism; no filler. 'EhViewer's strategy' is mildly jargon-y, but the following clause explains it, so nothing is wasted.

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 annotations covering safety and an output schema covering returns, the remaining gap is routing guidance: this tool sits among many search siblings and the description never says when it beats them. For a derived-similarity tool in a crowded namespace, that omission leaves the definition merely adequate.

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

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

Schema description coverage is 100%, and the schema already documents site, gallery, galleryUrl, and the mutual-exclusion note. The description adds no parameter-level detail beyond what is in 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?

The description states a specific verb (find) and resource (similar galleries) and even names the algorithm family (EhViewer's strategy), which distinguishes it from generic search siblings like eh_search_galleries. It is slightly weaker on stating that the input is a source gallery (gid/token or URL) rather than free-text terms.

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 or when-not-to-use guidance, and no mention of alternatives such as eh_search_galleries. The similarity intent is implied by the word 'similar', but the agent must infer the routing decision itself.

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

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

Beyond the annotations (readOnlyHint, idempotentHint, openWorldHint, destructiveHint=false), the description reveals meaningful behavioral traits: serial enumeration, complete/ordered output, and no image downloads. These traits help an agent set expectations about performance and side effects. There is no contradiction with the annotations.

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

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

A single sentence that front-loads the core behavior and constraints with no filler. Every phrase contributes: 'serially', 'every gallery preview page', 'complete, ordered image-page list', and 'without downloading images'.

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

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

Given the rich output schema and annotations, the description adds the essential behavioral context an agent needs to select and invoke the tool correctly. It clearly states what the tool does, how it behaves, and what it avoids, leaving parameter details to the schema.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no additional meaning about parameters like site, gallery, maxImages, or galleryUrl; it relies entirely on the schema for parameter semantics.

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

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

The description clearly states a specific verb ('enumerate'), resource ('every gallery preview page'), and result ('complete, ordered image-page list'), plus a scope constraint ('without downloading images'). It does not explicitly differentiate this from the sibling eh_get_gallery_pages, though the 'every' phrasing implies broader coverage.

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 conveys a clear usage context: use this when you need a complete, ordered enumeration of gallery image pages without downloading the images themselves. However, it does not explicitly name alternatives or state when not to use it, so it falls short of explicit routing guidance.

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

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

Annotations already mark the tool as read-only, idempotent, and non-destructive. The description adds value by explicitly noting that no purchase or archive-key consumption occurs, and by indicating the operation reflects the authenticated user's balance. This goes beyond a generic read-only declaration, though it omits details like error or rate-limit 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 entire description is one tight sentence that front-loads the key behavior and result contents, followed by an explicit non-side-effect guarantee. There is no filler or repetition of schema details.

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

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

Combined with a rich input schema, an output schema, and annotations indicating safe read-only behavior, the description fully covers what the tool does and its side-effect profile. Nothing critical needed for an agent to select and invoke the tool is missing.

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

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

Schema description coverage is 100%, so the input schema fully documents the site, gallery object, and galleryUrl parameters. The description does not add additional parameter-level meaning, 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 uses a specific verb ('Read') and names the exact resource ('authenticated archive page's balance, available resolutions, sizes, and costs'), while explicitly noting it does not purchase or return archive keys. This clearly distinguishes it from the many read-oriented sibling tools like eh_get_gallery_detail or eh_get_all_gallery_pages.

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 'without purchasing or returning archive keys' clearly frames this as a pre-purchase inspection tool for archive options. It does not explicitly name alternatives or state when not to use it, but the context is sufficiently clear for an agent to know when this tool is relevant.

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

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

The annotations already declare readOnlyHint/idempotentHint/destructiveHint, so the description's 'without modifying favorites' adds no new safety information. However, it does add behavioral context beyond the annotations by specifying that the result is scoped to the authenticated user, limited to ten categories, and includes counts/total/current selection.

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

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

A single sentence front-loads the action, resource, and exact data delivered, with no filler or repetition. The phrase 'without modifying favorites' earns its place by reinforcing the read-only contract.

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

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

With a complete input schema, an output schema available, and annotations covering safety, the description adds exactly the missing context: the user-scoped ten-category summary and current-selection behavior. Nothing essential is missing for an agent to invoke this tool correctly.

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

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

Schema description coverage is 100%, and the one parameter (site) has a clear enum, default, and description. The tool description does not restate parameter behavior, which is acceptable because the schema already carries the full semantic burden. 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 uses a specific verb ('Read') and names both the resource ('favorite categories') and the exact returned data ('names, counts, total, current selection'), making the tool's purpose unambiguous. It also explicitly distinguishes this from mutation by adding 'without modifying favorites.'

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 makes the read-only use case clear—retrieve the authenticated user's favorite-category summary—but it does not mention when to prefer this tool over siblings like eh_get_favorite_detail or eh_search_favorites, nor any exclusion criteria. Usage context is implied by the resource name rather than stated.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful context by noting the result is 'authenticated' (user-specific state) and explicitly lists the data returned, going slightly beyond the annotations.

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

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

The description is a single, front-loaded sentence that communicates the action, scope, and key output fields without wasted words. It is concise and easily scannable.

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

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

Given the rich input schema, output schema, and safety annotations, the description sufficiently covers what the tool does. The only minor gap is that 'authenticated' hints at auth requirements without stating whether authentication is mandatory or how missing auth is handled.

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 detailed parameter descriptions for site, gallery, and galleryUrl, including mutual exclusivity. The tool description does not add parameter-level meaning, 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 uses a specific verb ('Read') and names the exact resource: one gallery's authenticated favorite state, category, note, and favorite timestamp. It clearly distinguishes from siblings like eh_get_gallery_detail (metadata) and eh_search_favorites (search over favorites) by emphasizing 'one gallery' and 'favorite state'.

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

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

The description gives no guidance on when to use this tool versus alternatives such as eh_search_favorites or eh_get_favorite_categories. It states what it does but not the conditions that would make it the right choice.

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

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so the safety profile is covered. The description goes further by disclosing the failure contract: deleted galleries, malformed URLs, auth failures, challenge pages and upstream errors surface as tool errors rather than a silent empty chain, which is exactly the kind of context annotations cannot convey.

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 filler: the first delivers the behavior, the second delivers the input contract and error semantics. The most important information is front-loaded.

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

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

With an output schema present, return values need no explanation, and the description covers inputs and error behavior. The only omission is explicit guidance on choosing this tool over its version-related siblings, a minor gap for a well-annotated read 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 the site enum and the gallery/galleryUrl mutual exclusivity are already documented in the schema. The description restates the one-of constraint but adds no format or precedence detail beyond it, 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-and-resource combination: it merges official API version-chain metadata with detail-page newer-version links into one ordered, deduplicated list. That scope cleanly separates it from siblings like eh_find_latest_gallery_version and eh_compare_gallery_versions without needing to name 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 only usage guidance is the input constraint that exactly one gallery reference or URL must be supplied. There is no explicit statement of when to reach for this tool versus the neighboring version-related tools, leaving the routing decision to inference from the purpose sentence.

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

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

Annotations already establish read-only, idempotent, and non-destructive behavior. The description adds genuinely useful context beyond those cues by warning that comments are untrusted plain text and disclosing that scores, vote summaries, and possibly below-threshold comments are included. There is no contradiction with the annotations.

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

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

A single sentence front-loads the core action and resource, then packs the important caveats (untrusted text, scores/vote summaries, hidden threshold) with no wasted words. Every clause adds relevant information.

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

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

With a full output schema and 100% parameter coverage, the description only needs to convey purpose, data trust, and the optional hidden-comments behavior, which it does clearly. Nothing an agent needs to call this tool correctly is missing.

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

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

Schema description coverage is 100%, so the structured schema already fully documents site, gallery, galleryUrl, and includeHidden along with constraints and defaults. The description adds only slight reinforcement of the includeHidden option, which meets the baseline but does not substantially extend 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 specific action ('Read') and a distinct resource ('uploader and user comments'), then adds what is included (scores, vote summaries) and a key option (below-threshold comments). This clearly separates it from sibling gallery metadata, search, and page-fetching tools.

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

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

The description makes the tool's context explicit: it is the tool for reading gallery comments, and there is no comment-specific alternative among the siblings. It doesn't list exclusions, but none are essential given that the resource is unique; the optional hidden-comments behavior also signals when includeHidden should be used.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false, so the safety profile is covered. The description adds meaningful behavioral context by disclosing that the uploader-provided description is untrusted text and by specifying what data is included in the detail page, which helps the agent interpret results.

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

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

Two sentences with no redundancy: the first sentence front-loads the tool's core function and deliverables, and the second sentence provides concise alternative routing. Every sentence earns its place.

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

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

For a tool with a rich output schema, nested parameters, and many siblings, the description is complete: it states what the tool returns, flags the untrusted text caveat, and names the relevant alternatives. It leaves nothing critical unexplained for an agent to invoke it correctly.

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

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

Schema description coverage is 100%, so every parameter is already documented in the schema, including the site enum, gallery object with gid/token, and galleryUrl. The description does not need to add parameter-level meaning; the baseline of 3 applies because it adds no extra semantics beyond the schema.

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

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

The description uses a specific verb ('Read') with a clear resource ('one gallery's detail page') and lists the actual content returned: structured fields, grouped tags with strength, rating statistics, parent/newer versions, and uploader description. It also names sibling tools that serve different purposes, making differentiation easy.

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

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

The description explicitly routes the agent to alternatives: eh_get_gallery_metadata for authoritative API metadata in batches, eh_get_gallery_comments for comments, and eh_get_torrents for torrent records and URLs. This gives clear when-to-use and when-not-to-use guidance beyond what the schema provides.

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

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

Annotations already declare readOnly, idempotent, non-destructive, and open-world, so the safety profile is covered. The description adds that results are 'authoritative E-Hentai API' data, implying a canonical source, but says nothing about rate limits, ExHentai auth requirements, or partial-failure behavior when some of the 25 references are invalid. With annotations carrying most of the burden, a 3 fits.

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 filler. Scope and content come first, the routing guidance to the sibling second, so the most decision-relevant information is front-loaded.

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

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

With an output schema present, return-value detail is unnecessary, and annotations plus 100% schema coverage handle safety and inputs. The description covers scope and one alternative, leaving only the batch-variant disambiguation unaddressed for a tool in a large sibling cluster.

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 site enum, gid, and token constraints are all documented in the schema itself. The description only restates the 1-25 bound and does not clarify token format, site override precedence, or per-item error semantics. Baseline 3 is appropriate when 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?

States a specific verb and resource ('Get authoritative E-Hentai API metadata'), the batch scope (1-25 gallery references), and enumerates the returned content (namespaced tags, ratings, file size, torrent metadata, parent/current-version links). It explicitly positions itself against eh_get_gallery_detail, so an agent can separate the two without opening schemas.

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 positive trigger ('structured metadata and version-chain inputs') and a named alternative with its own conditions ('use eh_get_gallery_detail for page-level fields, tag strength, or the uploader description'). It does not address the near-duplicate sibling eh_get_gallery_metadata_batch or the version-chain tools (eh_get_gallery_chain, eh_compare_gallery_versions), which is the main remaining ambiguity.

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

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so safety is covered. The description adds genuinely useful behavior beyond that: server-side chunking into official 25-item API batches, preserved input order, and per-input success/error accounting, which tells the agent partial failures are possible and results are positional.

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 scope and followed by the operational detail. No filler and nothing repeated from the title or schema.

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 re-explained, yet the description usefully previews the per-input result shape and counts. For a batch tool with nested item objects, this covers the key call-time concerns (limit, chunking, ordering, partial failure) without over-explaining.

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 both parameters (site enum and the galleries array with gid/token constraints) are already fully documented. The description reinforces the 500 cap and ordering but adds no format, validation, or default behavior beyond what the schema states, 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 and resource ("Get official metadata") plus the distinguishing scope ("up to 500 galleries"), which cleanly separates it from the single-gallery sibling eh_get_gallery_metadata. It never names that sibling explicitly, so an agent must infer the batch-vs-single distinction from the name and count.

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 500-item ceiling and batching note imply this is the bulk path, but there is no explicit when-to-use guidance, no condition selecting it over eh_get_gallery_metadata or eh_resolve_gallery_batch, and no stated prerequisites (auth, site scoping). Usage is inferable rather than stated.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds no behavioral context beyond the output content and does not disclose external-site quirks, rate limits, or failure modes; however, it does not contradict the annotations.

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

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

One sentence, front-loaded with the action and the key scope limit. There is no filler or redundant restating of the 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?

An output schema exists and annotations cover the safety profile, so the description does not need to explain return values. The only notable gap is the lack of explicit sibling routing, but for a read-only single-page list operation with a fully documented schema, the definition is sufficiently complete.

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

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

The input schema documents 100% of parameters, including the gallery/galleryUrl mutual exclusivity, previewPage semantics, token pattern, and site enum. The description adds no parameter-level meaning beyond referring abstractly to 'one gallery preview page,' so the schema carries the burden.

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

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

The description uses a specific verb ('List') and names the exact resource: image-page numbers, page tokens, URLs, and preview thumbnails. The phrase 'from one gallery preview page' clearly scopes the tool and distinguishes it from the sibling eh_get_all_gallery_pages.

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 scope 'from one gallery preview page' implies when the tool should be used, but there is no explicit guidance about alternatives or when not to use it. An agent must infer that eh_get_all_gallery_pages would be the choice for multiple preview pages.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds valuable behavioral context beyond annotations: it states that the original-image URL is returned only 'when available' and lists navigation links and page keys as outputs. No contradiction with annotations.

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

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

The description is a single, front-loaded sentence with no filler. It begins with the action and resource, then compactly lists the output components. 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 read-only, idempotent single-page resolution tool, the description covers the essential purpose and output semantics, and the output schema provides return-value details. The only meaningful gap is explicit routing guidance against gallery-page siblings, which is minor given the clarity of the rest.

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

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

Schema description coverage is 100%, with every parameter (page, site, pageUrl) having its own description. The tool description adds no parameter-level detail, but the schema fully carries that burden, so a 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 uses a specific verb ('Resolve') and clearly names the resource ('one E-Hentai image page') plus the expected outputs: displayed image URL, original-image URL when available, navigation links, and page keys. It is clear and distinct from gallery-level tools, though it does not explicitly name any sibling to differentiate itself.

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

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

Usage is implied by the word 'one' — this tool resolves a single image page rather than a full gallery. However, the description does not explicitly explain when to prefer this over sibling tools like eh_get_gallery_pages or eh_get_all_gallery_pages, nor does it mention exclusions or alternative conditions.

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

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

Annotations already declare read-only, idempotent, non-destructive and open-world behavior, so the safety profile is covered. The description adds a genuinely useful trait beyond that — the selected site drives both the request and the base URL for relative gallery links — though it does not mention result counts or pagination 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?

Three sentences, zero waste, with the core action front-loaded and the routing guidance placed last where a reader deciding between tools will find 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?

An output schema exists and annotations cover the safety profile, so the description only needed to establish purpose, source selection, and sibling routing — all present. Nothing an agent needs to invoke this correctly is missing.

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

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

Schema coverage is 100% for the single enum'd site parameter, so the baseline is 3. The description goes further by explaining what the site value actually controls (request target and relative-link base URL), which the schema's own property text does not clearly convey.

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

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

States a specific verb and resource ('List the current popular galleries') and names the two supported sources, which distinguishes it immediately from the many eh_search_* siblings.

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

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

Explicitly routes the agent: 'Use eh_search_galleries when query filters are needed instead of the site's popular ranking.' The alternative and the condition selecting it are both stated, leaving nothing to inference.

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

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

Annotations already mark it as read-only, idempotent, non-destructive, and open-world. The description adds the critical behavior that it requires no network request, which aligns perfectly with the annotations and provides additional clarity. No contradiction.

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

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

A single, front-loaded sentence conveys the full purpose and the key usage note (no network request). 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?

Given zero parameters and a rich output schema, the description makes it clear what the tool does and that it's safe to call. The open-world hint implies the output changes based on state, but the description could explicitly state it returns static cached data.

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 zero parameters, so the description adds clear value by specifying what will be returned (categories, namespaces, qualifiers, operators, limits) without needing to document parameters.

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

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

The description uses specific verbs like "return" and lists concrete resources (categories, namespaces, qualifiers, operators, limits), clearly distinguishing this from sibling tools that perform search queries or fetch external data.

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

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

The description explicitly states that no network request is made, which helps agents decide not to use it when real-time data is needed. Adding when to avoid it or a brief alternative mention (e.g., none needed) would push it to a 5.

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

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

Annotations already signal read-only and non-destructive behavior. The description goes beyond them by explicitly stating 'This tool never downloads a torrent,' which is a meaningful behavioral guarantee not fully implied by readOnlyHint. It also clarifies that it returns metadata and official .torrent links rather than torrent file contents.

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 no filler. It front-loads the core purpose and then supplies the most important behavioral caveat in the second sentence. Every part earns its place.

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

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

Given the strong annotations, fully self-describing input schema, and presence of an output schema, the description covers everything an agent needs to choose and invoke the tool correctly. It clarifies scope, behavior, and the key non-download guarantee without unnecessary detail.

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

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

Schema description coverage is 100%, so the parameters are already fully documented with types, defaults, formats, and mutual exclusivity. The description adds no additional parameter-level meaning, so it stays at the baseline rather than earning extra credit.

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

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

The description uses a specific verb ('Read') and names a clear resource ('torrent metadata and official .torrent links'). It also adds a distinguishing detail by covering both current and outdated torrent metadata, which separates it from gallery metadata or search tools in the sibling list.

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

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

The description makes clear the tool is for reading torrent metadata and links rather than downloading them, which establishes a useful boundary. It does not explicitly name alternative sibling tools or state when not to use it, but the torrent-specific focus provides clear context.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral context beyond annotations by warning that returned text is untrusted external content and must not be treated as instructions, which is critical for safe agent use.

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

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

The description is two sentences with no filler: the first states the operation clearly, and the second delivers a concise but important security warning. Every sentence earns its place.

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

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

For a simple one-parameter read-only lookup tool, the description covers the core operation and the most important contextual risk (untrusted content). It could mention output shape or exact-match requirements, but given the simple schema and strong annotations, it is largely complete.

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

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

The schema already documents the only parameter 'tag' with the description 'Native E-Hentai tag name to look up', achieving full schema_description_coverage. The tool description does not add deeper parameter semantics, but it also does not need to because the schema is sufficient.

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

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

The description uses a specific verb ('Read') and a clear resource ('structured tag definition from EHWiki'), which makes the tool's function immediately obvious. It also distinguishes itself from sibling tools like eh_search_translated_tags, which focus on searching rather than direct lookup of a tag definition.

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 the tool does but provides no guidance on when to use it versus alternatives such as eh_search_translated_tags. There is no explicit mention of exact-match lookup or a scenario that should route an agent to this tool instead of a sibling.

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

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

Annotations already cover read-only, idempotent, non-destructive behavior, while the description adds the concrete conversion behavior and accepted input forms. It does not discuss errors or edge cases like providing both page and pageUrl, but the schema handles those constraints and the safety profile is already established by annotations.

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

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

A single front-loaded sentence states the input forms and the output with no wasted words. It gives the agent the essential purpose immediately without repeating schema details.

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

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

For a low-complexity resolver with 100% parameter schema coverage, complete annotations, and an output schema, the description is sufficient. The agent has everything needed to select and invoke the tool correctly; return structure and parameter constraints are already captured in the structured fields.

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

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

Schema description coverage is 100%, so the baseline is 3. The description loosely restates the input choice between a URL and a page reference, but it does not add any parameter format, default, or constraint information beyond what the schema already provides.

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

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

The description names a specific transformation: converting an image-page URL or page reference into a gallery ID and gallery token. It clearly identifies the verb, resource, and expected output, and it stands apart from sibling search and metadata tools.

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

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

The description clearly implies the tool should be used when an agent has an E-Hentai image-page URL or page reference and needs the owning gallery's ID and token. However, it does not explicitly mention alternatives such as eh_resolve_gallery_batch for multiple references or state when not to use this tool, so it stops short of full guidance.

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

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so safety is covered. The description adds genuinely useful behavior beyond that: input order and duplicates are preserved, and the call returns per-input results with success/error counts, implying partial failures do not abort the batch. It does not mention rate limits or auth needs for the official API path.

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, both front-loaded with the core operation and its guarantees, with no repetition. 'Through the official API' is mild filler but the rest earns its place.

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

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

With an output schema present, return-value detail is not required, and the description still summarizes the result shape (per-input input/success/error counts). Batch limits, ordering and duplicate handling are covered; only alternative-tool routing and any API/auth caveats are absent.

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 site, pages, gid, page and pageToken including formats and constraints. The description adds no syntax or format detail beyond the schema, making the baseline 3 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 ('Resolve') and resource ('image-page references to gallery tokens') plus the batch scope (1-500), so the operation is unambiguous. It never names the singular sibling eh_resolve_gallery, leaving the agent to infer the batch/single split from the name and limit 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?

The 1-500 range implies this is the bulk path, and 'preserving input order and duplicates' hints at when bulk resolution is appropriate. However, there is no explicit when-to-use or when-not-to-use guidance relative to eh_resolve_gallery or any alternative, so the routing decision is left to inference.

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

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

Annotations already declare read-only, idempotent, non-destructive, open-world behavior. The description adds genuinely new facts beyond those: hashing happens locally and the file is never uploaded, which is the key privacy/behavioral trait for this tool. It stops short of describing search-result behavior or failure modes.

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 zero filler; the local-processing and no-upload facts are front-loaded where an agent will see them.

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, annotations cover the safety profile, and the one behavior an agent could not infer from structured fields (no upload, local hashing) is stated. Nothing essential for correct invocation is missing.

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

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

Schema description coverage is 100%, so both parameters (path, site) are already documented in the schema, including the absolute-path requirement and enum values. The description only echoes the absolute-file notion and says nothing about the site parameter, so baseline 3 is right.

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 sequence of actions (read file, compute SHA-1, exact image search) on a specific resource, which cleanly separates it from eh_search_by_hash (takes a hash, not a file) and eh_find_similar_galleries (visual similarity, not exact). An agent can pick the right tool 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?

"One explicitly provided absolute local file" implies when the tool applies, and the schema's constraints reinforce it. But there is no explicit when-not guidance and no routing to eh_search_by_hash or eh_find_similar_galleries for the adjacent cases an agent is likely to face.

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

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

Annotations already declare readOnlyHint, idempotentHint, and openWorldHint, so the safety and repeatability profile is covered. The description only adds the no-upload detail and exactness of the match; it says nothing about result behavior on a miss or pagination.

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 tightly written sentence with the verb, resource, input constraint, and differentiator all front-loaded. No filler.

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

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

An output schema exists and the annotations carry the safety profile, so the description need not explain return values. For a simple two-parameter lookup it is nearly complete, though nothing is said about the site override behavior mentioned in the schema.

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

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

Schema description coverage is 100%, so both sha1 and site are fully documented in the schema. The description merely restates the hash format already given in the sha1 description and says nothing about the site parameter, so baseline 3 applies.

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

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

States a specific verb (Search), resource (E-Hentai by image SHA-1 hash), and the exact input constraint (40-character hash). The phrase 'without uploading the image' distinguishes it from the sibling eh_search_by_file, which is the closest alternative.

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 'without uploading the image' clause implicitly tells the agent to choose this over an upload-based search when a hash is already known. No explicit when-not condition or named alternative is given, so it falls short of a 5.

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

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so the safety profile is covered structurally. The description adds that the search targets the authenticated user's account, implying an auth requirement, but says nothing about result limits, pagination behavior, or how cursors chain across calls.

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 resource and scoping qualifiers lead. It is appropriately terse, though it packs three facets into one clause without much structure.

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

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

With an output schema present, return values need not be described, and annotations cover the safety profile. However, for a cursor-paginated search tool distinguished from several sibling search tools, the description omits routing guidance and cursor-chaining behavior, leaving 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 description coverage is 100%, so the schema already documents all six parameters including site, cursor direction, and category enum. The description names three of them (query, category, cursor) but adds no syntax, format, or interaction detail (e.g. how 'next'/'prev'/'seek' relate) beyond what the schema provides.

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

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

States a specific verb (Search) and resource (favorites), scoped to the authenticated user's E-Hentai/ExHentai account, and names the search facets (query, category, cursor). It does not explicitly distinguish itself from close siblings like eh_search_galleries or eh_search_watched, 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?

The phrase 'authenticated user's favorites' implies the use case (searching your own favorites rather than the general gallery index), but there is no explicit when-to-use guidance or named alternative such as eh_search_watched or eh_search_galleries. Usage is inferable but not stated.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds the tag-syntax prerequisite and mentions cursor filters, but says nothing about pagination/return behavior beyond the schema. With annotations carrying the load, 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?

Three sentences, front-loaded with the core capability and then the two practical usage notes. No filler, though the tag-syntax sentence could be slightly tighter.

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 rich output schema, full annotation coverage and 100% parameter documentation, the description rounds out the definition by explaining query syntax and tag resolution. Nothing essential to call it correctly appears missing.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real value by explaining namespace-qualified tag syntax (artist:name, female:tag) and the native-vs-translated token distinction, which the schema does not elaborate.

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 (search galleries on E-Hentai or ExHentai) and enumerates the filter families it supports. It distinguishes itself from eh_search_translated_tags by routing tag-name resolution there, but does not differentiate from the many other search siblings (batch, watched, by_hash, favorites).

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 explicit routing guidance: resolve translated Chinese/English tag names with eh_search_translated_tags first, while native tags can be passed directly. It lacks any when-not conditions (e.g., when to prefer batch or hash search), so it stops short of a 5.

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

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so the safety profile is covered. The description adds genuinely non-obvious behavior: a 10-page budget cap, deduplication of gallery references, and a resume cursor emitted when truncation occurs.

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 scan scope, the dedup behavior, and the truncation/resume semantics each carry distinct information.

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

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

With an output schema present the return shape need not be explained, and 100% schema coverage plus annotations cover parameters and safety. The only real shortfall is absent routing guidance versus the sibling search tools.

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 13 documented parameters, so the schema does the heavy lifting and a 3 is the baseline. The description only loosely maps to two of them (page budget → maxPages, resume cursor → next) and adds no syntax or filtering 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+resource (batch gallery search across up to 10 pages) plus the differentiating behaviors: no metadata expansion, deduplication, and resume cursor. An agent can distinguish it from single-page search and the metadata-batch sibling, though no sibling is named 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?

Usage is implied rather than spelled out: 'without metadata expansion' hints that metadata-batch tools are the alternative, and the page-budget framing implies bulk scanning. There is no explicit when-to-use/when-not statement or named alternative.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, open world), so the description is free to add transformation semantics: that results are merged into works, installments grouped into series, uniqueWorkCount is heuristic, and every work carries a confidence level. These are genuinely useful behavioral disclosures beyond the structured fields, though rate-limiting implications are left to the schema's maxPages text.

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 dense sentences with no filler, front-loading the search scope and pipeline before the output-shape note about galleryCount and uniqueWorkCount. Efficient, though the second sentence packs several distinct facts together.

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 explain return structure, yet it helpfully clarifies the semantics of galleryCount vs uniqueWorkCount and the confidence level. For a 13-parameter, merge-heavy tool this is close to complete; the main missing piece is routing guidance relative to sibling search tools.

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 fully documents all 13 parameters including the rate-limited maxPages and next cursor. The description only echoes the 'up to 10 result pages' constraint (maxPages) without adding format or interaction detail, 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 multi-step pipeline: search result pages, fetch official metadata, merge version/language variants into works, and group installments into series. That is far more informative than a tautology. It does not, however, differentiate itself from close siblings like eh_search_galleries or eh_search_galleries_batch, leaving the agent to infer 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?

There is no explicit when-to-use, when-not-to-use, or named alternative. The agent is told what the tool does but not under what conditions it should be preferred over eh_search_galleries or eh_search_galleries_batch, which appear to cover overlapping ground.

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

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

Annotations already cover read-only, open-world, idempotent, and non-destructive behavior. The description adds non-obvious context: results include all matching candidates, no ambiguity resolution is performed, and returned data is subject to the source database license. No contradiction with annotations.

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

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

Three short sentences with no filler; the core action is front-loaded, the output behavior follows, and the license caveat is kept to one clause. Every sentence contributes relevant information.

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

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

For a read-only lookup with two well-documented parameters and an output schema, the description is largely complete. The only notable gap is not mentioning when to use this tool versus the tag-definition sibling, but this does not prevent 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 the schema already documents both 'query' and 'limit' clearly. The description's mention of Chinese/original English tag adds no parameter-specific meaning beyond what the schema provides, so a baseline 3 is appropriate.

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

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

The description states a specific verb ('Resolve'), a concrete input ('Chinese translated tag name or original English tag'), and a named source ('official EhTagTranslation database'). It also clarifies that it returns candidates and searchQuery fragments, but it does not explicitly distinguish this tool from the sibling eh_lookup_tag_definition.

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

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

Usage is implied rather than explicit: an agent can infer this is for obtaining native searchQuery fragments without resolving ambiguity, but the description gives no when-not-to-use guidance and names no alternatives such as eh_lookup_tag_definition.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, so the closing sentence largely restates what structured data provides. It does add one genuinely new trait — the feed is scoped to the authenticated user — but omits pagination/cursor behavior, result ordering, or rate considerations, keeping it at a baseline-plus level.

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, both front-loaded with the operative noun phrase ('watched-tag gallery feed') and the safety boundary. Nothing is repeated and there is no filler.

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

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

For a read-only, cursor-paged search tool with full annotation coverage, an output schema, and 100% schema documentation, the description covers the essentials: scope (watched tags), operation type (read), and auth requirement. The missing piece is routing against the many sibling search tools, which leaves a small 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% and every one of the 14 parameters carries its own description, including the enum for site and the category list. The description's phrase 'native search, category, advanced-filter, and cursor controls' only loosely groups those parameters and 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 specific verb ('Read') and a precise resource ('watched-tag gallery feed'), and enumerates the functional scope (native search, categories, advanced filters, cursor controls). This distinguishes it implicitly from eh_search_favorites and eh_search_galleries, though it never names a sibling to make the boundary explicit.

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

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

The description gives no guidance on when to choose this over eh_search_galleries, eh_search_favorites, or the batch variants. The only conditional statement ('never changes watched tags') is a safety reassurance, not a usage rule, so the agent must infer selection criteria 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.