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

Annotations already mark it read-only/open-world; the description adds genuine behavioral detail: 'Every factual sentence is cited or dropped', warnings[] flagging, 'fused across sources with reciprocal rank fusion', and the required API key. These are not visible in annotations or schema.

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

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

Purpose and sibling routing are front-loaded, and each subsequent sentence adds distinct information: citation behavior, warning flags, auth requirement, and response_format variant. 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?

With an output schema present, return structure does not need description. The description covers purpose, when-to-use, safety/behavior, auth prerequisites, and the detailed variant, leaving no critical gap for an agent deciding to call this tool.

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

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

Schema covers 100% of the 5 params, so the baseline is 3. The description enriches two critical params: query is framed as 'plain English', and response_format:'detailed' is tied to specific outputs (routing, citation grades, resolvability).

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

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

States the exact operation: 'Ask a question in plain English and get a synthesized answer with inline [n] citations'. The sentence 'Use this instead of library_ask when you want a cited answer rather than raw results' explicitly differentiates it from the closest sibling, so an agent can select it 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?

Names the alternative 'library_ask' and the condition that selects it ('when you want a cited answer rather than raw results'). Also gives a conditional usage branch: 'Set response_format: "detailed" for the full result set, routing, citation grades, and resolvability.'

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 the safety profile (readOnlyHint=true, destructiveHint=false, openWorldHint=true), and the description adds context beyond them: it discloses the routing behavior, parallel search execution, the automatic source-selection logic, and the OPENAI_API_KEY environment requirement. It does not cover rate limits or failure behavior, but with annotations carrying the safety burden, the added behavioral context is solid.

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

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

Three sentences, with core behavior front-loaded and routing guidance following immediately. Every sentence earns its place, but the response_format directive in the final sentence partially duplicates what the schema already documents, so it is not maximally tight.

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

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

For a complex routing tool, the description covers the essential operational context: what it does, when to use it, the sibling alternative, an environment prerequisite, and a configuration hint. Since an output schema exists, the omission of return-value details is acceptable. Only minor gaps remain, such as rate limits or cost implications of parallel searching.

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 — including the response_format enum meanings — is already documented in the input schema. The description's 'Set response_format: detailed for routing reasons' adds framing but largely restates what the schema's enum description already says about diagnostics and routing reasons. This is the appropriate baseline-3 case where the schema does the heavy lifting.

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

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

The description opens with a specific verb and resource: it takes plain-English requests and routes them across all 152 libraries, generating per-source queries and searching in parallel. It also differentiates itself from its key sibling, library_search, by explicitly naming what it is not ('when you already know which source to query'). An agent can tell what this tool does without opening the schema.

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

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

The description explicitly declares this the default entry point for any natural-language request and names the exact alternative condition, 'Use library_search instead when you already know which source to query.' This is the strongest form of usage guidance: it gives when-to-use, when-not-to-use, and the sibling tool that applies instead.

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

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

Beyond the readOnly/idempotent annotations, the description discloses OpenAlex-to-OpenCitations fallback behavior, Crossref DOI lookup pacing (one-at-a-time, first 20 only), and what 'detailed' returns including routing reasons and diagnostics. This is substantial behavioral context.

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

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

Three sentences front-load the core operation and direction semantics, then pack necessary caveats into later clauses. Every clause adds decision-relevant information with no fluff.

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

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

The description covers identifiers, direction, fallback sources, formatting behavior, response modes, and diagnostics. Combined with the rich schema and output schema, an agent has what it needs 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 coverage is 100%, but the description adds important cross-parameter meaning: format triggers a formatted bibliography string, BibTeX has special Crossref behavior, and response_format controls field richness. This enriches the schema rather than repeating it.

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

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

The description names a specific verb ('List'), the resource (works cited by or citing a scholarly item), and the two directions with clear semantics. It also distinguishes itself from sibling query tools by framing the output as a citation graph operation.

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 signals that this tool is for resolved items, explicitly accepting IDs from library_search or library_ask or a bare DOI/arXiv ID. It explains when to use format and response_format, though it does not explicitly name sibling tools to exclude.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so safety is covered. The description adds valuable behavioral context beyond annotations: the probe layer reads eval/probe-latest.json, the published-install caveat ('status stays unknown until this process itself calls it'), and the data merge behavior. This meaningfully informs the agent about edge cases and internal mechanics.

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

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

The description is three sentences: core function with output states, behavioral caveat, and usage/parameter guidance. It is front-loaded, every sentence earns its place, and there is no redundant filler.

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

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

The tool has a rich output schema, clear annotations, and a description that covers purpose, behavior, edge cases, usage triggers, and parameter guidance. For a read-only health-reporting tool with all-optional parameters, nothing an agent needs to invoke it correctly is missing.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds value by explaining that response_format: 'detailed' exposes 'error rate, latency, and quota usage'—quotas are not mentioned in the schema—and by framing source/cluster as optional filters. This is a modest but genuine addition 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 states a specific verb ('Report') and resource ('per-source health'), enumerates the exact output states ('ok', 'degraded', 'down', 'key_missing', 'unknown'), and describes the data fusion mechanism. This clearly distinguishes it from siblings like library_list_sources (listing) or library_search (retrieval).

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 explicit when-to-use guidance: 'Use before relying on a source that has been erroring, or to check whether a key is configured.' It does not explicitly name exclusions or alternative tools, but the context is clear and actionable for an agent.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false. The description adds specific behavioral details: fetching text, semantic chunking, and OCR quality scoring, plus the full-text source constraint. It does not contradict annotations and provides useful context beyond 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?

The description is exceptionally concise, front-loaded with the core purpose, and every clause adds information: 'Dry run', 'fetch text, chunk semantically, score OCR quality', 'No writes', 'Full-text sources only'. No waste.

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

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

The description covers the core function and constraints, and an output schema exists, which helps. However, the undocumented id parameter is a notable gap, and the description doesn't explain what 'score OCR quality' means in practice. Overall, it's adequate but not complete for an agent to use without ambiguity.

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 50%: the source parameter is documented with a helpful reference to library_list_sources, but the id parameter has no description. The tool description does not mention parameters at all, so it fails to compensate for the undocumented id. An agent would have to infer that id identifies a document, which is a significant gap.

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

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

The description clearly states the tool's specific actions: dry run, fetch text, chunk semantically, score OCR quality, with explicit constraints (no writes, full-text sources only). This distinguishes it from sibling tools like library_ingest or library_read, making its purpose unambiguous.

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

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

The description provides clear context for when to use the tool: it's a dry run, no writes, and only for full-text sources. While it doesn't name specific alternatives, these constraints imply when it's appropriate versus the ingest tool. This is sufficient guidance for an agent.

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

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

Annotations already provide idempotency and safety hints, so the description needs less behavioral disclosure. It adds worthwhile context: the chunk-embed-store processing stages, source-type limitation, and required authentication environment variables. It does not go into failure modes or error behavior, but the bar is lowered by 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 compact and front-loads the core action. Each sentence adds a distinct type of information: operation, idempotency, source scope, and prerequisites. It is slightly terse, but not bloated.

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 two-parameter tool with an output schema and helpful annotations, the description covers key constraints and auth needs. Still, the meaning of 'id' is left unexplained, and the relationship to the 'source' parameter is only implied, leaving a notable gap for an agent preparing a correct call.

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

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

Schema coverage is only 50%, and the description does not explain how 'id' and 'source' map to the action beyond saying 'a text.' The schema's source description is helpful, but the id parameter has no description anywhere, and the tool description does not compensate for that gap.

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

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

The description names a specific pipeline ('Chunk, embed, and store a text') and a concrete resource (vector database), which clearly separates it from the sibling tools like library_read or library_search. The title reinforces the resource, and the 'Full-text sources only' constraint adds precision.

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

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

The description gives clear preconditions ('Full-text sources only', required API keys) that tell an agent when it is allowed to use the tool. However, it does not explicitly explain when to prefer this over a sibling like library_index, and no alternatives are named.

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. The description adds meaningful behavioral context beyond that: the source count of 152 is computed dynamically from the live registry at startup, so it may change between runs. It also signals that the response is a complete enumeration rather than a paginated or filtered subset.

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 action, the full scope, the count, and the returned detail level. The parenthetical about the live registry is compact and adds value without wasting space.

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

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

For a parameterless list tool, the description is complete: it states what is listed, how much is listed, and what information each entry carries. Combined with the output schema and annotations, an agent has everything needed to invoke and interpret the tool correctly.

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

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

The tool has zero parameters, so the description does not need to explain parameter usage. The baseline of 4 applies because there is no parameter burden for the description to carry.

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

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

The description states a specific verb and resource: 'List all 152 library sources' with the content of the listing ('descriptions and capabilities'). This clearly distinguishes it from siblings like library_search or library_read, which operate on content rather than enumerating sources.

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 intended use case is implied—use this to discover the full set of available library sources before selecting one—but there is no explicit when-to-use, when-not-to-use, or mention of alternatives. The description is sufficient for the obvious listing purpose, but it does not actively route the agent away from sibling tools.

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

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

The description adds useful behavioral details beyond the annotations: full-text results are cleaned and truncated at 200k characters, and metadata sources return details plus an external URL. This complements the readOnlyHint and idempotentHint annotations without contradiction.

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

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

The description is compact and front-loaded: the first sentence states the core purpose, and the second sentence adds the key variant behavior. Every sentence earns its place with no redundancy.

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

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

Given the output schema exists, the description appropriately avoids detailing return values. It covers the main behavioral variation and works with the schema to give the agent enough to call the tool correctly. Minor gaps like error behavior are not critical here.

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 explains both id and source. The description adds context about source type behavior but does not introduce new parameter-specific semantics beyond what the schema provides.

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

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

The description clearly identifies the operation: fetching text from a library source. It adds meaningful differentiation between full-text and metadata sources, which helps distinguish this tool from search-oriented siblings like library_search or library_ask.

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

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

The description implies usage context through the phrase 'from a library source' and the parameter note that ids come from library_search or library_ask. However, it does not explicitly say when to use this tool versus alternatives or state exclusions, leaving some inference to the agent.

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

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

Annotations already provide readOnly, openWorld, idempotent, and non-destructive hints, so the description carries a lower burden. It adds input provenance ('paperId from a semanticscholar search result') and a result-count ceiling, but doesn't disclose potential external API failures, rate limits, or invalid-ID 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 short sentences, no filler, and the core purpose is front-loaded before usage guidance. Every sentence adds 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 two-parameter, output-schema-backed tool with strong annotations, the description provides enough context: source of the id, operation, and result limit. It doesn't discuss failure modes, but the simplicity and annotations make that a minor gap.

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

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

Schema coverage is 50%; id is documented in the schema, and the description enriches it by requiring it come from a Semantic Scholar search result. limit has no schema description but the 'Returns up to 500 similar papers' phrase indirectly conveys its meaning, though not fully.

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

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

The description opens with a specific verb and resource: 'Get papers similar to a given paper' via Semantic Scholar's recommendation engine. This clearly separates it from siblings like library_search and library_citations by identifying the operation as recommendation rather than search or citation lookup.

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

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

It gives an explicit when-to-use condition: you need an existing paperId from a Semantic Scholar search result and want similar papers. It doesn't spell out alternatives or exclusions, but the context is clear enough for an agent to pick this over search or citations.

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

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

Annotations already declare the tool read-only and non-destructive. The description adds valuable behavioral context beyond that: it requires an external API key, calls library_answer as a sub-step, recurses with halved breadth, and stops on coverage/depth/time/no-new-sources. It does not repeat safety hints or contradict 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?

The description is dense but every sentence adds distinct information: the algorithm, the stopping conditions, the auth requirement, and the response_format distinctions. It front-loads the core purpose and avoids filler or restating 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?

For a complex recursive tool, the description covers the main workflow, termination criteria, hard prerequisite, and output options. An output schema exists, so return-value details need not be spelled out. Nothing required for an agent to decide on and invoke the 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 coverage is 100%, so the baseline is 3. The description adds extra meaning by explaining response_format 'detailed' returns per-round breakdown, elapsed time, citation grades, resolvability, and objectives/coverage outline, and by clarifying that breadth halves each round. This goes beyond the schema's brief parameter descriptions.

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

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

The description opens with 'Deep research on a topic' and gives a concrete algorithm: outline objectives, generate queries, answer via library_answer, extract learnings, recurse. This is a specific verb plus resource and process, and it clearly distinguishes the tool from single-shot siblings like library_ask or library_search by framing it as a recursive orchestration tool.

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

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

The description provides clear context for when to use the tool: 'Deep research on a topic' with 3–7 coverage objectives and recursion. It also implies it should be used for multi-round, exhaustive research rather than simple lookups, though it does not explicitly name exclusions or alternative tools, 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 establish a safe, read-only, idempotent operation, so the description does not need to restate that. It adds useful behavioral context beyond the annotations by distinguishing [full text] sources, which support read/ingest, from [metadata] sources, which return discovery info and external URLs only.

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

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

Two short, purposeful paragraphs: the core action, the key alternative, and source-type capability guidance. No filler or repetition of schema/annotation content.

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

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

Given the strong schema (100% parameter coverage), explicit output schema, and annotations, the description covers the remaining operational context: which source to target, how to route to library_ask, and what result types to expect from metadata-only sources. Nothing needed to call it correctly is missing.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds a little extra meaning by framing the query as a structured search of a specific source rather than a natural-language question, which reinforces the query and source parameters without replacing the schema.

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

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

The description states a specific action ('Search a specific library source by name') and names the resource (library source). It also differentiates from library_ask, which handles natural-language queries across multiple sources, so an agent can tell them apart.

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

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

It explicitly says to use library_ask instead for natural language queries across multiple sources. It also explains when library_read and library_ingest apply based on [full text] source markings, giving clear routing to the relevant siblings.

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