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

The description discloses a key behavioral trait: a failed write may be partial and recommends inspecting stage and file_id before retrying. This goes beyond the annotations, which only provide basic hints (readOnlyHint, idempotentHint, destructiveHint), adding practical failure-handling 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?

Two sentences, front-loaded with the primary action and a useful warning. Efficient and to the point, with 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?

The description is insufficient for an agent to correctly use the tool: it doesn't explain parameter semantics, doesn't specify the return structure (though no output schema exists), and lacks usage guidance relative to siblings. It only partially addresses failure handling.

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

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

The description provides no information about any of the five parameters, despite the schema having zero description coverage. An agent would not know the purpose of title, source, metadata, or even that knowledge_id identifies the target knowledge base. This 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 action: upload text, wait for processing, then attach to a knowledge base. It distinguishes itself from sibling tools by focusing on adding content, though it doesn't explicitly name alternatives.

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 guidance on when to use this tool versus alternatives like knowledge_create or knowledge_update. The description implies usage for adding text to a knowledge base but doesn't mention any 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 cover the read-only/idempotent/destructive profile, so the description only needs to add return behavior and side effects. It does add the key behavioral fact that a new knowledge base is created and its knowledge_id is returned, which is essential for the agent to use the result.

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

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

The description is one concise sentence with no filler. It front-loads the action and resource, then specifies the return value, making every word useful.

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

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

The tool is simple and annotations cover the mutation profile, but the description omits usage guidance and parameter semantics, both of which are relevant for correct invocation. The return value is stated, which partially compensates for the lack of an output schema.

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

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

Schema description coverage is 0%, so the description must compensate, but it never explains the 'name' or 'description' parameters beyond what the schema already shows. The only parameter information comes from field titles and a default value, which is insufficient.

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 ('Create') and a specific resource ('Open WebUI knowledge base'), and adds the useful return value ('returns its knowledge_id'). This clearly differentiates it from sibling read/update/delete/search tools.

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

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

The description gives no guidance on when to use this tool versus alternatives, especially the similarly named 'knowledge_add'. There are no stated prerequisites, exclusions, or conditions that would route an agent to a different 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 include destructiveHint=true, so the description's job is to add context. It does clarify that the operation preserves the shared file and doesn't delete the base, which is valuable context about scope. However, it doesn't explain consequences for references or permissions, nor does it detail idempotency, which is not covered 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?

The description is two short sentences with zero waste. It front-loads the core action ('Detach a file from this base') and adds the retention constraint immediately. Every word earns its place.

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

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

Given the tool's simplicity (2 params, no nested objects, no output schema) and annotations covering destructive behavior, the description is mostly adequate. However, the complete lack of parameter explanation and lack of any mention of return value or side effects beyond base retention leaves some gaps for an agent unfamiliar with 'knowledge' concepts.

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

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

Schema description coverage is 0%, and the description does not explain what knowledge_id and file_id represent or how they relate. It only says 'file from this base' which hints at file_id being the file and knowledge_id the base, but that's minimal. With zero coverage, the description provides insufficient compensation for understanding the parameters.

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

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

The description clearly states a specific verb ('Detach') and resource ('file from this base'), distinguishing it from destructive deletion. It differentiates from siblings by implying it's not a whole-base deletion, but it doesn't explicitly name a sibling like knowledge_get_file or knowledge_list for contrast.

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 for detaching a file while retaining the shared file, and the exclusion of deleting the whole base is a when-not. However, it doesn't explicitly state when to use this tool versus alternatives like knowledge_update or rag_get_file, and provides no conditions or prerequisites.

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 destructiveHint=false, so the safety profile is covered. The description adds that the result includes brief file metadata and mentions file_id as an identifier, but it does not clarify the output structure or whether pagination or other limits apply.

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

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

The description is a single concise sentence with the core action front-loaded. However, the trailing clause about file_id is ambiguous and slightly detracts from clarity despite the brevity.

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 1-parameter read-only retrieval tool, the description is minimal but lacks an explanation of knowledge_id, the relationship between knowledge_id and file_id, or when this tool should be used over knowledge_get_file. The missing output schema makes this gap more significant.

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

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

Schema description coverage is 0%, and the description does not explain the required knowledge_id parameter beyond the schema title. It introduces file_id, which is not an input parameter, potentially confusing agents rather than helping them understand what knowledge_id refers to.

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 clear verb ('Get') and resource ('a knowledge base'), and adds 'brief file metadata' to suggest its scope. However, it does not explicitly differentiate from the sibling knowledge_get_file, and the phrase 'brief file metadata' is somewhat ambiguous.

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

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

There is no guidance on when to use this tool versus siblings like knowledge_list, knowledge_get_file, or rag_get_file. No alternatives or conditions are mentioned, leaving the agent to infer usage from the tool name alone.

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

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

Annotations already cover the safety profile (readOnlyHint=true, destructiveHint=false), and the description adds genuinely useful behavior: it returns a character count and an explicit truncated flag, implying long content may be cut off and that the caller can detect this. Nothing here contradicts 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 front-loaded sentence with no filler; the verb comes first and every phrase ('extracted file text', 'total_chars', 'explicit truncated flag') adds meaning a caller benefits from. Nothing is redundant or missing in terms of economy.

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 one-parameter read-only tool with annotations covering safety, this is nearly complete: the return characteristics are summarized despite there being no output schema. However, it leaves unclear how a valid file_id is obtained and which of the many knowledge/rag siblings is the intended choice for a given retrieval need.

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

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

Schema description coverage is 0%, so the description must compensate, but it says nothing about file_id—its format, provenance, or how to obtain it. The single parameter is self-descriptive by name and required, which limits the harm, but the description adds no parameter-level meaning.

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

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

The description uses a specific verb and resource ('Get extracted file text') and names the return fields (total_chars, truncated flag), so an agent can understand what the tool does. It does not explicitly distinguish this from siblings like knowledge_get or rag_get_file, leaving some ambiguity about which getter to reach for.

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

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

There is no guidance on when to use this tool versus knowledge_get, rag_get_file, knowledge_search, or the other siblings. No context for when-not-to-use or which alternative fits a different intent is given, so an agent must rely on naming conventions alone.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds meaningful behavioral context: results are filtered by 'accessible' (permission scoping) and exclude documents/vectors, clarifying the output's size and nature. It doesn't detail output format, but for a simple list that's acceptable.

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 of 11 words, front-loaded with the verb and resource, and every phrase earns its place by clarifying scope ('all accessible') and filtering ('without documents or vectors'). No wasted words.

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

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

For a parameterless, read-only listing tool, the description is complete. It states what it lists, the scope of the list, and what it excludes. With no output schema, the description still gives enough for an agent to call it correctly and set expectations without additional context.

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 and schema coverage is 100%, so the baseline is 4. The description adds nothing about parameters, but none are needed. No further semantic value is required.

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 clear verb ('List'), a specific resource ('Open WebUI knowledge bases'), and explicitly scopes the result ('all accessible', 'without documents or vectors'). This distinguishes it from siblings that fetch full contents or specific items, such as knowledge_get or rag_get_file.

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

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

The description gives clear context: it lists accessible bases only and excludes documents/vectors, which implies when to choose it over heavier retrieval tools. However, it does not explicitly name alternatives or state when not to use it, 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 readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral details: 'No answer generation' clarifies the output is raw retrieval only, and 'raw upstream values, not normalized relevance' warns that scores are not calibrated. This goes beyond the annotations without contradicting them.

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

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

The description is compact—two sentences—with the core purpose and ordering front-loaded. Each sentence conveys necessary information without padding. The key behavioral caveats ('No answer generation' and raw scores) are placed immediately after the purpose, making it easy to scan.

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

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

Given 3 parameters, no output schema, and a non-trivial search tool, the description covers purpose, behavior, and one parameter nuance. It omits the meaning of top_k, default count limits, and the exact structure of returned fragments. While it mentions scores/distances, it does not fully specify the output shape. This is adequate but not comprehensive.

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

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

Schema description coverage is 0%, so the description must carry the meaning. It precisely explains the semantics of knowledge_ids (omitted vs empty), which is non-obvious and valuable. However, it does not clarify the query parameter (obvious) or top_k (what it controls, default behavior). Since it covers only one of three parameters in depth, it partially compensates but leaves gaps.

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

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

The description clearly states the verb 'Retrieve' and the resource 'fragments', and specifies the ordering ('rank order'). It also differentiates itself from answer-generation tools via 'No answer generation', which helps distinguish it from siblings like rag_search. However, it does not explicitly name any sibling tool, so it stops 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 description provides concrete guidance for the knowledge_ids parameter (omitted vs empty array), which tells the agent how to restrict the search scope. It does not, however, offer explicit guidance on when to prefer this tool over alternatives like rag_search or knowledge_get. The differentiation is implied ('No answer generation') but not stated as a usage rule.

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 (destructiveHint=true, idempotentHint=false), the description adds crucial behavioral context: writes are not atomic, other bases may change, reindexing occurs, and failed calls should prompt inspection of stage/file_id before retrying. This is exactly the kind of non-obvious behavior an agent needs.

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, each earning its place: the core action, the side effect, and the retry/failure caveat. Critical information is front-loaded 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?

The description covers the most important operational risks for a destructive, non-idempotent mutation with no output schema: side effects, non-atomicity, and retry guidance. It falls slightly short on explaining the knowledge_id parameter and what exactly 'stage' refers to in the failure inspection step.

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

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

Schema description coverage is 0%, so the description must compensate, but it only implicitly ties 'text' to file text and mentions file_id in the failure guidance. The knowledge_id parameter is left entirely unexplained, and no parameter-level semantics are provided.

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: replace shared file text and reindex the base. It also discloses an important scoping fact ('Other bases sharing this file may change'), which clearly separates this update tool from sibling create/add/delete/search 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 intended use is implied by the purpose statement, and the warning about other bases sharing the file suggests caution, but the description does not explicitly state when to choose this tool over alternatives or when not to use it. No sibling tool is named as a fallback.

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 annotated readOnlyHint=true and destructiveHint=false, the description adds no behavioral context. It doesn't describe what retrieving a file entails, error scenarios, or return format. The alias reference is purely structural, not behavioral.

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

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

The description is one short sentence, which is concise in size, but it under-specifies nearly everything. The sentence's only content is a cross-reference, not a meaningful description, so it fails to earn its place as a functional explanation.

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

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

With no output schema and a single parameter, the description must carry the full burden, but it leaves the tool's behavior, input semantics, and return value entirely to inference from a sibling. This is incomplete and unusable as a standalone definition.

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

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

Schema description coverage is 0%, and the description provides no information about file_id. The agent only sees 'File Id' as a string with no explanation of its source, format, or usage.

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 'Alias of knowledge_get_file' does not state the tool's own purpose; it only redirects to a sibling tool. An agent reading this in isolation must look up knowledge_get_file to learn the function, which is a tautological cross-reference rather than a clear verb+resource statement.

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

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

There is no guidance on when to use this tool versus knowledge_get_file or any other sibling. The alias remark implies interchangeability but does not state conditions, exclusions, or alternatives.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds the behavioral scope: it only checks the authenticated API and does not verify Qdrant or models. This is useful context beyond the annotations, though it doesn't describe the response format or error behavior.

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

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

The description is a single sentence that front-loads the main action and immediately clarifies scope with the exclusion. Every word earns its place; 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?

For a zero-parameter health-check tool with readOnlyHint=true and destructiveHint=false, the description is nearly complete. It clearly states what is checked and what is not. The only minor gap is the lack of detail about the return value (e.g., status codes or response shape), but with no output schema and a simple health check, this is a minor omission.

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 0 parameters, so the schema is trivially complete. The description doesn't need to explain parameters, and the baseline for 0 params is 4. The description adds no parameter info, but none is needed.

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 ('Check') and resource ('authenticated Open WebUI Knowledge API'), and distinguishes itself from siblings by explicitly noting what it does not verify ('does not verify Qdrant or models'). It is clear and concise, though it could be slightly more explicit about the health-check nature.

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

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

The description implies when to use this tool: to check the health of the Knowledge API specifically, not Qdrant or models. It doesn't explicitly name alternatives, but the sibling list and the exclusion of Qdrant/models provide clear context for when this tool is appropriate.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description only adds that the tool is an alias and provides no additional behavioral context such as return format, pagination, or side effects.

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

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

The description is a single four-word sentence with no filler or redundant information. It is appropriately sized for a simple alias tool and front-loads the only meaningful fact.

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 zero-parameter read-only alias, the description is minimally viable, and no output schema exists to explain return values. It would be more complete if it briefly stated what the alias returns or explicitly said 'use knowledge_list' as the canonical implementation.

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

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

There are zero parameters, so the schema covers everything and the description has no parameter burden. This matches the baseline for parameter-free tools.

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

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

The description clearly identifies the tool as an alias of knowledge_list, which distinguishes it from siblings and points to the intended operation. It does not explicitly restate the underlying verb/resource, but the alias relationship makes the purpose unambiguous if knowledge_list is understood.

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

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

No guidance is given about when to use this alias versus knowledge_list or the other sibling tools. The alias statement implies equivalence, but there is no explicit when-to-use, when-not-to-use, or alternative-selector information.

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 destructiveHint=false, but the description adds no behavioral context beyond pointing to knowledge_search. It does not disclose return format, pagination, ordering, or any side effects.

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

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

The description is extremely short, but this is under-specification rather than effective conciseness. It spends only four words and omits substance that should be present in a standalone tool definition.

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

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

For a 3-parameter tool with no output schema and no schema descriptions, the description is far from complete. It relies entirely on knowledge_search being understood elsewhere and provides no fallback context for correct invocation.

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

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

Schema description coverage is 0% and the description provides no parameter information. The query, top_k, and knowledge_ids parameters are left entirely undocumented by the description, so the agent gains no additional meaning beyond the raw 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 only says 'Alias of knowledge_search', so it does not state any concrete verb or resource. It delegates meaning to a sibling tool's description rather than explaining what rag_search actually does.

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

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

There is no guidance about when to use this tool or when to prefer alternatives. The alias relationship implies interchangeability with knowledge_search, but it does not explain contexts, exclusions, or prerequisites.

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