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

The description adds behavioral context about how modes affect the use of conversation history and document context, which is useful given that annotations provide no positive hints. However, it does not disclose whether messages are persisted, whether authentication is required, or other mutation side effects, leaving some behavioral ambiguity.

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 main purpose appears in the first sentence, and the mode explanation and parameter list follow logically. Every line earns its place with no redundant 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 the core purpose, mode semantics, and parameters. An output schema exists, so return value details are not needed. It does not explicitly discuss threads or relationship to sibling chat tools, but for a simple chat tool with three parameters, it is reasonably 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?

With schema description coverage at 0%, the description compensates by explaining each parameter in the Args section, including the meaning of the mode enum values. The descriptions for slug and message are minimal but sufficient, and the mode explanation adds real semantic value beyond the bare 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 begins with 'Send a message to a workspace and get a response,' which clearly specifies the verb and resource. It also distinguishes the two modes ('chat' vs 'query'), and the phrase 'to a workspace' helps differentiate from sibling tools like anythingllm_chat_in_thread.

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 mode descriptions provide explicit guidance on when to use 'chat' vs 'query' (context + history vs documents only). However, it does not explicitly mention sibling alternatives or exclusions (e.g., when to use chat_in_thread instead), so it lacks full tool-selection 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 indicate readOnlyHint=false, meaning this is not a read-only operation, but the description provides no additional behavioral context. It does not disclose side effects (e.g., message persistence), authentication needs, or what the response contains. The description is too minimal to inform the agent about the tool's runtime 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 concise and front-loaded with the main purpose, followed by a compact Args list. It is efficient with no redundant text. It could be better structured as a proper docstring, but it meets clarity needs without bloat.

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

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

The tool sends a message in a thread, but the description omits important contextual details: what the response looks like (output schema exists but is not described), how to obtain valid slugs, and the behavioral difference between 'chat' and 'query' modes. Given the tool's interaction complexity, this is incomplete.

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 provides terse glosses like 'Workspace slug' and 'Thread slug'. The mode parameter is described as "'chat' or 'query'" which merely repeats the enum values without explaining their difference or usage context. This adds little beyond the schema itself.

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 'Send a message within a specific workspace thread', which is a specific verb+resource action. It distinguishes from sibling tools like anythingllm_chat (which likely handles non-thread chat) by explicitly mentioning the thread context.

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 through the description: this tool is for thread-scoped chat. However, no explicit guidance is given on when to prefer this over anythingllm_chat or any other alternative. There is no mention of exclusions or 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 readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds specificity about what is verified (API key validity, reachability), which 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 a single, front-loaded sentence that directly states the tool's purpose. No 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?

Given the tool's simplicity (no parameters, output schema exists, safe read-only operation), the description fully explains its purpose and behavior. No additional context is needed.

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 baseline is 4. The description doesn't need to explain parameter semantics since there are none.

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 ('verify') and clearly identifies the resource scope (API key validity and AnythingLLM reachability). It distinguishes itself from sibling tools that perform CRUD operations by focusing on authentication and connectivity.

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 as a connectivity/auth preflight check but does not explicitly state when to use it or name alternatives. There are no exclusion criteria, but the intended context is clear from the description.

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 are all false (not read-only, not idempotent, not destructive), providing no useful behavioral information. The description adds nothing beyond the basic action, omitting details like duplicate folder behavior, side effects, or permission requirements. The agent is left without critical safety or execution context.

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

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

The description is extremely concise, using a single sentence and a simple arg list. It is front-loaded with the core purpose and contains no fluff. For such a simple one-parameter tool, this size is appropriate.

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?

Despite the tool's simplicity, the description leaves significant context gaps. It does not explain what 'document folder' means in the AnythingLLM context, whether it is scoped to a workspace, or what happens if a folder with the same name exists. The output schema exists, so return values are covered, but the operational context 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?

The input schema has one required parameter 'name' with no schema-level description (0% coverage). The description compensates minimally by saying 'name: Name for the new folder,' which clarifies the parameter's purpose but adds no constraints or additional meaning. It meets the baseline but does not enrich the semantics beyond what the parameter title implies.

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

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

The description clearly states the tool's purpose: 'Create a new document folder in AnythingLLM.' This is a specific verb+resource construction that unambiguously identifies the action. It does not explicitly distinguish from sibling tools like create_workspace, but the resource 'folder' is distinct enough to avoid confusion.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention any prerequisites, exclusions, or relationships to sibling tools such as remove_folder or list_documents_in_folder. There is no context to help an agent decide if this is the right tool.

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

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

Annotations already declare readOnlyHint=false, indicating a mutation. The description adds the workspace context but does not disclose additional behavioral traits such as non-idempotency or side effects beyond creation. It does not contradict annotations.

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

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

The description is extremely concise, front-loaded with the action, and includes a simple args list. Every sentence adds value without unnecessary verbosity.

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

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

Given the simplicity of the tool (2 params, no nested objects, output schema exists), the description is sufficient. It covers purpose and parameters. However, it could mention that the slug must refer to an existing workspace, but this is 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?

The description explains both parameters: 'slug: Workspace slug' and 'name: Optional thread name.' This adds meaning beyond the raw schema, which only provides titles and required status. With 0% schema description coverage, this fully compensates.

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 explicitly states 'Create a new chat thread within a workspace,' using a specific verb and resource. It clearly distinguishes from sibling tools like create_workspace, update_thread, and chat_in_thread, which have different actions.

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 does not provide guidance on when to use this tool versus alternatives. It does not mention prerequisites like needing an existing workspace, nor exclusions such as 'use update_thread to modify a thread.' The context is implied but not explicitly 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 are all false and provide no safety or behavioral signal. The description only restates the action and offers no detail about idempotency, uniqueness constraints, side effects, or what happens on error. This is essentially a tautology of the tool name.

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 very short and front-loaded, with no filler. The two-line docstring format efficiently conveys purpose and the single parameter.

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 create operation with an output schema, it covers the essential input adequately. However, the lack of behavioral detail, such as name uniqueness or error conditions, leaves gaps in understanding, especially given the total absence of annotation support.

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 clarify parameters. It lists 'name: Name for the new workspace', which adds minimal context beyond the schema's title 'Name', but does not explain format, uniqueness, or other constraints.

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 'Create a new workspace' with a specific verb and resource. This distinguishes it from sibling tools like update_workspace, delete_workspace, and list_workspaces.

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

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

No guidance is provided on when to use this tool versus alternatives. It does not mention prerequisites, limitations, or cases where creation may fail, so the agent gets no context for choosing this tool.

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

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

Annotations already declare destructiveHint=true, so the safety profile is known. The description adds the specific object (thread) and workspace context but does not disclose additional behavioral traits like permanence or cascading effects. This is adequate but not rich.

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

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

The description is extremely concise with a clear action and two short parameter explanations. Every word earns its place; 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 simplicity of the tool, the presence of an output schema, and annotations, the description plus schema adequately cover the needed context. It lacks explicit usage guidelines but the purpose is straightforward.

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%, but the description clarifies both parameters: 'slug: Workspace slug' and 'thread_slug: Thread slug to delete'. This adds meaningful meaning beyond the raw schema, though not highly detailed.

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 'Delete a chat thread from a workspace' with a specific verb and resource, and distinguishes from sibling tools like delete_workspace or remove_documents.

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 the tool (when you want to delete a chat thread) but does not provide explicit when/when-not guidance or alternatives. It lacks exclusions or comparisons with other deletion 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 significant behavioral context beyond the destructiveHint annotation by stating the action 'cannot be undone.' This reinforces the irreversibility and warns the agent of the permanent consequence, which is valuable for decision-making.

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

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

The description is extremely concise: one sentence for the action and one for the parameter. Every word earns its place, and the critical warning 'cannot be undone' is front-loaded immediately after the verb.

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

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

For a simple destructive operation with one parameter, the description is fully complete. It states the action, the irreversibility, and the parameter meaning. The presence of an output schema means return-value details are not required, and nothing essential is missing.

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

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

With 0% schema description coverage, the description compensates fully by explaining that the 'slug' parameter is the 'Workspace slug to delete.' This provides the exact meaning needed for correct invocation, going beyond the schema's type-only definition.

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 ('delete') and resource ('workspace'), clearly distinguishing it from sibling tools like create, update, or get workspace. The permanence is emphasized, leaving no ambiguity about the operation's purpose.

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

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

It clearly indicates this is for permanently deleting a workspace, providing clear context for when to use it. It does not explicitly mention alternatives or when-not-to-use, but the context is unambiguous.

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, covering the safety profile. The description adds the global scope but does not mention output format, size limits, or pagination. This is adequate given annotations but adds limited extra context.

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

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

The description is a single, clear sentence with no waste. Every word contributes to the tool's purpose and scope.

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

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

Given the tool has no parameters, an output schema exists, and annotations declare it safe and read-only, the description sufficiently covers the purpose. No additional context is needed for an AI 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?

With zero parameters, the description does not need to explain parameter semantics. The baseline of 4 applies, and the absence of parameters is clearly reflected in the schema.

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

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

The description uses a specific verb 'Export' with a clear resource 'all chat logs from all workspaces'. This clearly distinguishes it from sibling tools like get_chat_history which likely targets a specific workspace/thread.

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 its usage by specifying the scope ('all chat logs from all workspaces'), making clear when to use this over more targeted tools. However, it does not explicitly state exclusions or when not to use it.

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 known. The description adds the upload-related context but discloses no further behavioral traits such as authentication or rate limits, which is acceptable for a trivial getter.

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 that fully communicates the tool's purpose. No wasted words or redundant 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?

Given the zero-parameter complexity, strong annotations (read-only, idempotent, non-destructive), and the presence of an output schema (not shown but indicated), the description sufficiently covers the tool's behavior. It is complete for a straightforward list-returning getter.

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 no parameters, so the baseline score of 4 applies. The description does not need to explain parameter semantics, and the empty schema confirms none are 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 'Get the list of file types that AnythingLLM accepts for upload' clearly states the action (get) and resource (accepted file types), and its purpose is easily distinguished from sibling tools like upload_file or list_workspaces.

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 context is clear: it returns file types relevant to upload operations. It doesn't explicitly mention alternatives or when-not scenarios, but as a simple getter, the usage context is effectively implied without needing exclusions.

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 clear. The description adds no additional behavioral context beyond the read operation, but for a simple getter this is adequate; no contradiction exists.

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

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

The description is extremely concise, with a single line of purpose and a one-line parameter description. Every word is necessary and the structure is clear, making it an effective and appropriately sized description.

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, annotations cover safety, and an output schema exists. The description sufficiently identifies the workspace context and the parameter. It could mention that this is the main chat history for a workspace and not include thread chats, but that is implied by the workspace parameter.

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

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

The description adds 'Workspace slug' to explain the slug parameter, providing minimal semantic clarification over the schema's bare 'slug' title. However, it does not explain how to obtain the slug or any constraints, and schema description coverage is 0%.

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 'get' with resource 'chat history for a workspace' and identifies the slug parameter. It clearly distinguishes from sibling tools like anythingllm_get_thread_chats (thread-specific) and anythingllm_export_chats (export), making the tool's scope 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 no guidance on when to use this tool versus alternatives. It does not mention anythingllm_get_thread_chats or anythingllm_export_chats, leaving the agent to infer usage context 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?

The annotations already declare the tool as read-only and idempotent. The description adds context about the document identifier format and that it returns metadata, which is consistent with the annotations. No extra behavioral details (e.g., error cases) are given, but the low-risk nature is 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?

The description is compact and well-structured: a clear purpose statement, an explanatory note on the parameter, and an Args block. Every sentence adds value.

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 single parameter, an output schema available, and annotations provided, the description sufficiently covers the tool's usage. The parameter is fully documented, and the tool's read-only nature is clear.

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

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

The schema has no description for doc_name, but the description fully explains that it is the internal document identifier returned by list_documents, with an example. This compensates perfectly for the 0% schema coverage.

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

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

The description clearly states the tool retrieves metadata and details for a specific document, identified by its stored name. It distinguishes itself from list_documents by focusing on a single document and explains the identifier format.

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 that doc_name comes from list_documents, indicating when this tool is appropriate (after listing). It does not explicitly mention alternatives or exclusions, but the context of retrieving a specific document is clear.

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 no behavioral context beyond what the annotations already provide (readOnly, idempotent, non-destructive). It does not disclose return format, auth requirements, or any side effects, so the agent gains no additional insight.

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, clear sentence with no filler. It is appropriately sized for the tool's simplicity and gets straight to the point.

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 that the tool has no parameters, is read-only, and has an output schema, the description is nearly complete. It could benefit from mentioning that the schema is returned as JSON or referencing the output schema, but for this simple use case, it is sufficient.

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 input schema is trivially complete. The description needs to explain no parameter semantics, and the baseline of 4 applies because there are no parameters to clarify.

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

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

The description clearly states the tool's purpose: to get the metadata schema for documents in AnythingLLM. It uses a specific verb ('Get') and identifies the exact resource, distinguishing it from sibling tools like get_document or list_documents.

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

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

No guidance is provided on when to use this tool versus alternatives. It does not mention any prerequisites, exclusions, or context that would help an agent decide between this and similar getter tools.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds content detail (what settings are included) but no further behavioral context such as pagination, exact return format, or side effects. Since annotations carry the safety burden, this is adequate but not enriched.

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 without filler. It conveys the core purpose and content efficiently, earning 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?

With no parameters, a simple read-only operation, and an output schema present, the description is fully sufficient. It doesn't need to explain return values because the schema handles that, and annotations cover safety. The tool is small and well-specified by the existing structured 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?

The tool has zero parameters and schema coverage is 100%, so there is nothing to explain. The description still adds meaning by listing examples of returned settings, which helps the agent understand what the tool returns. Baseline for zero parameters is 4.

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 ('Get') and names a clear resource ('AnythingLLM system settings'), with examples of content ('LLM provider, vector DB, embeddings'). It distinguishes itself from sibling tools like get_workspace or list_models by targeting system-level settings.

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

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

The description implies when to use this tool (when you need system settings) but provides no explicit guidance on when not to use it or which alternative to use. No alternatives are mentioned, so it falls at 'implied usage' rather than clear context or exclusions.

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 additional behavioral context beyond the obvious read operation, such as what data is returned or any constraints (e.g., requires existing workspace/thread). It simply restates the read nature without enriching the agent's understanding.

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

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

The description is extremely concise: a single sentence stating the purpose, followed by a clean two-bullet args list. No filler, no redundancy, and the key information is front-loaded. Every word earns its place.

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

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

For a simple read-only tool with two parameters, annotations covering safety, and an output schema present, the description is mostly complete. It covers purpose and parameter meaning, but lacks explicit usage alternatives and potential edge cases (e.g., thread not found). Given the tool's simplicity, the minor gaps are acceptable, but not perfect.

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

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

Schema description coverage is 0%, so the description must compensate. It adds brief definitions for both parameters ('slug: Workspace slug', 'thread_slug: Thread slug'), clarifying the ambiguous property names. However, it provides no format, validation rules, or guidance on how to obtain these values, so it only partially compensates.

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 ('Get chat history') and the specific resource ('a specific thread in a workspace'). It distinguishes from the sibling `anythingllm_get_chat_history` by explicitly narrowing to thread-level history, making the tool's purpose unambiguous.

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

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

The description implies usage context by mentioning 'specific thread in a workspace', but it does not explicitly state when to choose this over alternatives like `anythingllm_get_chat_history` or `anythingllm_chat_in_thread`. No when/when-not guidance is given, so it barely meets the 'implied usage' level.

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, covering the safety profile. The description adds that the tool returns a count of all vectors in the system, which is useful but limited; it does not disclose response shape or potential performance implications, though the output schema mitigates this.

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 that immediately states the tool's purpose. Every word earns its place, with no redundancy or extraneous information.

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

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

Given the tool's simplicity (zero params, output schema present, and safe annotations), the brief description fully covers the necessary context. The existence of an output schema eliminates the need to describe return values, making this complete for the tool's complexity.

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

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

The tool has zero parameters, and the schema description coverage is 100% (empty properties). There is nothing to explain, so the description's lack of parameter details is appropriate. The baseline of 4 for zero parameters 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 ('get') and resource ('total number of vectors'), clearly indicating this tool returns a count. It distinguishes itself from sibling tools like list_embeds by focusing on the aggregate count rather than listing vectors.

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

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

No guidance is provided on when to use this tool versus alternatives, such as list_embeds or search. There is no mention of ideal contexts or prerequisites, leaving the agent to infer usage solely from the name and minimal description.

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, which fully cover the safety profile. The description adds no additional behavioral context (e.g., error handling, return format specifics) but also does not contradict the annotations. It simply reiterates the read-only nature of retrieving information, which is acceptable given the strong annotation coverage.

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

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

The description is extremely concise: one sentence for the purpose and one line for the argument. It is front-loaded with the main action and contains no unnecessary words. Every part earns its place, making it easy to scan and parse.

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 read-only tool with one parameter, the description covers the essential purpose and parameter semantics. The output schema provides return structure, so return values are covered. The only minor gap is the lack of usage guidance relative to sibling tools (e.g., needing the slug from list_workspaces), but this is not critical for a straightforward read operation.

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

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

Schema description coverage is 0%, so the description must compensate. It does so effectively by defining the slug parameter with inline examples ('papers', 'lands'), clarifying what a workspace slug looks like and what values to use. This goes well beyond the schema's bare 'Slug' title and fully explains the 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 clearly states the action 'Get' and the resource 'workspace', specifying 'specific workspace' via a slug. This distinguishes it from sibling tools like anythingllm_list_workspaces (which lists all workspaces) and mutation tools like create/update/delete. The purpose is unambiguous and informative.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention list_workspaces for discovering slugs or clarify that this is for a single workspace read. The only implied usage is from the slug argument, but no explicit comparisons, prerequisites, or exclusions are given.

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 clear. The description adds the 'across all folders' scope, which is useful but not a deeper behavioral disclosure such as pagination or performance characteristics. With annotations doing the heavy lifting, a score of 3 is appropriate.

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

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

The description is a single sentence that is concise and front-loaded with the action. It contains no filler and every word adds meaning, covering verb, resource, and scope efficiently.

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

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

Given the tool's simplicity (no parameters, clear scope), the description is complete for its purpose. An output schema exists, so return values need not be described. The context provided by the description, combined with annotations and schema, is sufficient for an agent to select and invoke 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 input schema has zero parameters, so the baseline is 4. The description does not need to explain parameter semantics because there are none; the tool takes no arguments, and the description accurately reflects this by being param-free.

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') with a clear resource ('all uploaded documents') and explicit scope ('across all folders'). This distinguishes it from sibling tools like anythingllm_list_documents_in_folder, which target a single folder.

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 ('across all folders') but does not explicitly state when not to use it or name alternatives. It leaves the distinction from list_documents_in_folder to inference, providing only implied usage 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 readOnlyHint, idempotentHint, and destructiveHint, covering the safety profile. The description adds minimal behavioral context beyond the folder scope, which is expected from the tool name. It does not contradict annotations and provides no additional traits like auth or rate limits.

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

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

The description is concise and front-loaded, with a clear one-sentence purpose followed by a simple parameter explanation. Every word earns its place with no redundancy or filler.

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

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

Given the low complexity (one parameter), rich annotations (read-only, idempotent), and presence of an output schema, the description is sufficient. It covers what the tool does, the parameter meaning, and the safety profile via annotations, making it complete for this simple 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?

The schema has no parameter descriptions (0% coverage), but the description includes an Args section explaining folder_name as 'Folder name to list documents from.' This adds meaningful semantics beyond the bare schema, effectively compensating for the lack of schema 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 clearly states the tool lists all documents inside a specific folder, using a specific verb (List) and resource (documents in a folder). It distinguishes itself from sibling tools like anythingllm_list_documents, which presumably lists all documents without folder scoping.

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 a specific folder via the phrase 'inside a specific folder,' but it does not explicitly state when to use this tool versus alternatives or provide exclusion criteria. No alternatives are mentioned, though the sibling list suggests a distinction.

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 this as read-only, idempotent, and non-destructive, so the safety profile is fully covered. The description adds the key context that 'embeds' are 'public chat widgets', but discloses no additional behavioral details such as return format or pagination. This is adequate given the annotation coverage.

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

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

The description is a single, focused sentence that clearly states the purpose and clarifies terminology. Every word earns its place with no 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?

This is a simple list-all tool with no parameters, strong annotations, and an output schema. The description fully covers the tool's purpose and scope ('all embed configurations'), and because an output schema exists, return format details are not needed in the description. It is complete for its complexity.

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

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

The tool has zero parameters, so the baseline of 4 applies. The description does not need to explain parameters, and the schema is empty. The description adds no semantics beyond what the schema needs, but none are 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 uses a specific verb ('List') with a clear resource ('embed configurations') and clarifies the meaning with 'public chat widgets'. This clearly distinguishes it from sibling list tools like anythingllm_list_workspaces and anythingllm_list_documents.

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

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

The description implies usage: when you need to see embed configurations. However, it does not explicitly contrast with alternatives or mention when not to use it. For a trivial list operation, the context is clear but lacks explicit exclusions.

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 flag the operation as read-only, idempotent, and non-destructive. The description adds the meaningful context that listing is performed via an OpenAI-compatible endpoint, which clarifies API access semantics beyond what annotations 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?

The description is a single, front-loaded sentence with no redundancy. Every word adds value, clearly stating the operation and the endpoint type.

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 list operation with an output schema, the description fully captures the purpose and endpoint context. There is nothing missing for an agent to invoke 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 details. The baseline of 4 applies because there are no parameter semantics to elaborate on.

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 'List available models via the OpenAI-compatible endpoint' clearly states the action (list) and the resource (models). It distinguishes itself from sibling tools like list_workspaces and list_documents by specifying the domain of models.

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 tool's name and description make it obvious that it is used to enumerate models. While it doesn't explicitly state when not to use it, no alternative sibling tool serves the same purpose, so the intent is clear.

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, so the description does not need to restate safety. It adds valuable context beyond annotations by specifying the output fields and the 'all' scope, though it omits any caveats like pagination or authentication requirements.

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, well-structured sentence that front-loads the action and resource, and lists the returned data. 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 the tool's simplicity (no parameters, strong annotations, and an output schema), this description fully covers the purpose and scope. The mention of slugs, settings, and thread info rounds out the 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, so the description carries no parameter burden. The baseline 4 applies as there is nothing to explain beyond the schema, which is already complete.

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

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

The description clearly states the action ('List'), the resource ('all workspaces'), and the specific data returned ('slugs, settings, and thread info'). This directly distinguishes it from siblings like get_workspace which retrieves a single workspace.

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 purpose implies a clear use case: enumerating all workspaces. However, it does not explicitly mention when not to use it or suggest alternatives (e.g., 'for a single workspace, use get_workspace'), so it lacks explicit exclusions but 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=false and destructiveHint=false, so the write nature is clear. The description adds context on the required path format but does not explicitly disclose side effects like the original path being removed. 'Move' implies this, but there's no additional behavioral detail beyond annotations.

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

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

The description is organized with a clear purpose, explanation, and args section. There is some redundancy between the first paragraph and the Args block, both stating the 'from'/'to' requirement, but it remains concise and readable overall.

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 are covered. The tool has a single parameter and simple logic; the description explains the input format thoroughly. Minor missing details like folder creation behavior are not critical for basic usage, making it fairly complete.

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

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

Schema coverage is 0%—the schema only defines an array of objects without key details. The description fully compensates by specifying each entry must have 'from' and 'to' keys, providing an example, and referencing list_documents paths. This adds complete meaning beyond the schema.

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

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

The description states a specific verb and resource: 'Move documents between folders.' This clearly differentiates from sibling tools like upload_file_to_folder or remove_documents. The example further clarifies the operation, and the path format reference 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 clearly indicates the operation type ('Move documents between folders') and the required path format, which sets clear context. However, it does not explicitly mention when not to use it or name alternatives, so there is no exclusion 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 include destructiveHint=true, and the description adds valuable context: documents are removed from storage entirely and also from any workspaces that had them embedded. This goes beyond the annotation by detailing secondary 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 compact, front-loaded with purpose, then adds behavioral detail and a structured Args block. Every sentence earns its place without redundancy.

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

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

For a simple destructive tool with one parameter and an output schema, the description covers purpose, effects (including workspace impact), and parameter format. It doesn't mention error cases or prerequisites, but those are not critical given the output schema exists.

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

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

Schema coverage is 0% (only 'names' as array of strings), but the description compensates fully with an Args section that explains names are from list_documents and provides a concrete example. This is clear, actionable guidance.

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

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

The description clearly states 'Permanently delete one or more documents from the system' with a specific verb (delete) and resource (documents). It distinguishes from siblings like anythingllm_remove_folder (folders) and anythingllm_get_document (read 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 implies usage: when you need to permanently delete documents and notes they are removed from workspaces. It does not explicitly name alternatives or exclusions, but the context of sibling tools makes the intended use clear.

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 meaningful behavioral context beyond the annotations by noting the deletion is 'permanent' and includes 'all its contents.' This explicitly discloses the destructive scope and irreversibility, which is particularly valuable since the annotation already marks destructiveHint=true. No contradictions exist.

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

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

The description is extremely concise, with one sentence for the main function and one line for the parameter explanation. It is front-loaded with the critical information and contains no extraneous 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?

The tool is simple with a single parameter, an output schema, and annotations indicating destructive behavior. The description fully explains what is deleted and the parameter meaning, making it complete for an agent to select and invoke without ambiguity. No additional prerequisites or return-value details are necessary given the output schema.

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

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

The schema provides no description for the single parameter 'name', but the description compensates with 'Args: name: Folder name to delete.' This clarifies the parameter's meaning and purpose, though it does not add formatting or constraint details. Given the schema coverage is 0%, the description does adequately compensate for the one 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 clearly states the tool's function: 'Permanently delete a document folder and all its contents.' This provides a specific verb (delete) and resource (document folder) while also distinguishing from related tools like remove_documents (which deletes documents, not folders) and create_folder (which creates, not deletes). The scope of deletion (including contents) adds clarity.

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 in that this tool is for deleting a folder, but does not explicitly state when to use it versus alternatives. No exclusions or alternative tool mentions are given. The implied usage is straightforward, so it sits at 'implied usage' rather than 'no 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 readOnlyHint=true and idempotentHint=true, so no contradiction. The description adds useful behavioral context beyond annotations, such as the score_threshold semantics ('Lower = more results') and the top_n range (1-20, default 4). This helps the agent understand the search behavior and result control.

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 concise: a single purpose sentence followed by a clean argument list. No unnecessary words. Each line earns its place by specifying a parameter or behavior.

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, return values need no explanation. The description covers purpose, all parameters, and key behaviors. For a search tool with this complexity, it is complete. The sibling context also reinforces that this is the dedicated search operation.

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 carries full responsibility for parameter meaning. It documents all four parameters: slug, query, top_n (with range and default), and score_threshold (with range and default). This is exactly the kind of compensation 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 opens with a specific verb+resource: 'Search for relevant document chunks within a workspace using vector similarity.' This clearly distinguishes it from sibling tools like list_documents (listing) or chat (conversation). The method (vector similarity) adds further specificity.

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 (semantic search over chunks) but does not explicitly state when to use this tool over alternatives like chat or list_documents. There are no exclusionary statements or named alternative tools, so guidance is implicit rather than explicit.

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

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

Annotations already convey the write, idempotent, and non-destructive nature. The description adds context about the vectorization effect and clarifies that un-embedding leaves the file in storage, which goes beyond what annotations state. However, it does not detail edge cases (e.g., duplicate embeddings, errors), so a 4 is more fitting than 5.

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

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

The description is well-organized with a workflow list and per-argument explanations. Every sentence contributes meaningful guidance without fluff, balancing detail and readability effectively.

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 prerequisites (upload first), the embedding process, and the distinction between un-embedding and deletion. It also includes example paths and the UI equivalent, providing a complete context for correct use. An output schema exists, so return values need not be described.

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

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

With 0% schema description coverage, the description fully compensates by explaining each parameter: slug is the workspace, adds are document paths from list_documents, and deletes un-embed without deleting storage. It also provides a concrete example of a document path, making usage clear.

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

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

The description clearly states the tool's function: 'Embed or un-embed documents in a workspace' with the UI equivalent. It distinguishes itself from sibling tools by naming the specific action and referencing a workflow step, 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 explicit when-to-use guidance via a step-by-step workflow ('Typical workflow...'), positioning this tool as the final step after upload and listing. It also implies when not to use it by noting that un-embedding does not delete from storage, steering users toward deletion tools if permanent removal is intended.

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 idempotentHint=true and destructiveHint=false, covering idempotence and safety profile. The description adds the behavioral effect on LLM context, which is valuable. However, it does not disclose edge cases like error behavior if the document does not exist, or whether pinning overwrites an existing pin state. This is adequate but not extensive; 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 concise and well-structured. It opens with a clear summary, adds one sentence of semantic context, and then lists the arguments in an easy-to-scan Args block. Every sentence earns its place with no redundancy or filler.

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

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

The tool is simple and has an output schema, so return format is already specified. The description covers purpose, parameters, and the key behavioral effect (always in LLM context). It does not mention prerequisites such as 'document must exist' or failure modes, but given the idempotentHint and simple API, this is a minor gap. Overall, complete enough for correct use.

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

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

Input schema has 0% description coverage, yet the description fully compensates by explaining each parameter: slug as workspace slug, doc_path with a concrete example and source hint ('as returned by list_documents'), and pinned as a boolean toggle with explicit True/False meanings. This adds substantial meaning beyond the raw schema fields.

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 explicitly states the tool's action: 'Pin or unpin a document in a workspace.' This is a specific verb+resource construction that distinguishes it from sibling tools like list_documents, remove_documents, or get_document. The added explanation about pinned documents being always included in LLM context further clarifies its purpose.

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 context for when pinning is useful by explaining that pinned documents are always included in every query regardless of vector similarity. However, it does not explicitly mention alternatives or when not to use this tool, such as 'use list_documents to see current pin status' or 'prefer vector search for relevant-in-context documents.' This is clear context but lacks explicit exclusions/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 provide the key behavioral traits: readOnlyHint=false, destructiveHint=false, and idempotentHint=true. The description adds that it updates the thread name, which is consistent with these hints. However, it does not disclose any additional context such as permissions, side effects, or error conditions, which would be valuable beyond what annotations already tell us.

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 concise and front-loaded, starting with a clear one-sentence purpose statement followed by a simple args list. There is no extraneous information, and 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 rename operation with an output schema present, the description covers the action and all parameters adequately. It does not mention edge cases or prerequisites, but the annotations and simple nature of the tool make this acceptable. The absence of return value discussion is fine since an output schema exists.

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

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

The input schema has 0% description coverage, but the description provides brief semantics for all three parameters: 'slug' as workspace slug, 'thread_slug' as thread slug to update, and 'name' as new name. This compensates for the missing schema descriptions, though it could be more detailed about where to find these slugs or any formatting requirements.

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 'Update the name of an existing chat thread' with a specific verb (update) and resource (thread name), distinguishing it from sibling tools like anythingllm_delete_thread or anythingllm_create_thread. The purpose is unambiguous and specific.

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 by stating the action and listing the required arguments, but it does not provide explicit guidance on when to use this tool versus alternatives, nor does it mention exclusions or prerequisites. For a simple rename operation, the implied usage is adequate but could be improved with a note like 'Use when renaming an existing thread'.

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 does not disclose key behavioral details such as whether unspecified settings are preserved or reset to defaults when only a subset of parameters is provided. Annotations indicate idempotent and non-destructive behavior, but the description adds no operational context, leaving a critical ambiguity for an update tool.

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

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

The description opens with a clear, concise lead sentence followed by a compact Args list. Each parameter line is minimal and informative, with no redundancy or unnecessary detail.

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?

While all parameters are documented and an output schema exists, the description fails to clarify the update semantics—specifically whether it performs partial updates or full replacements of workspace settings. This is essential for correct invocation, so the description is not fully complete.

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

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

The schema has zero description coverage, but the tool description thoroughly explains all 8 parameters with concise meanings and ranges (e.g., temperature 0.0-1.0, topN 1-20) and clarifies chatMode values. This fully compensates for the lack of schema 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 clearly states 'Update workspace settings' and enumerates specific settings (name, temperature, prompt, similarity threshold), making the operation and resource explicit. The verb 'update' differentiates it from sibling tools like create_workspace and delete_workspace.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites. Usage is implied by the tool name and 'update' verb, but there is no context such as 'use for existing workspaces' or 'do not use for creation'.

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 simply restates the operation type ('Upload') without adding any behavioral context beyond what annotations already convey (readOnlyHint=false, openWorldHint=true). It does not disclose potential side effects like duplicate uploads, file type restrictions, or where the file is stored. While annotations cover the basic safety profile, the description adds no extra transparency.

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 concise and front-loaded, with one clear main sentence and an Args block that adds the key parameter detail. There is no redundant or irrelevant text, though the structure is minimal and could benefit from a bit more context.

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

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

For a tool with 1 parameter and an output schema, the basic action is clear. However, it misses important context: how this upload differs from 'upload_file_to_folder', whether a workspace is required, and the destination of the file. The output schema likely documents the return, but the operational context is incomplete.

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

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

The input schema has no descriptions for 'file_path', and schema coverage is 0%. The description compensates by stating 'Absolute path to the file on the local filesystem', which adds meaningful semantics. However, it does not provide additional constraints or format details, making it adequate but not thorough.

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) and the resource (file from local filesystem to AnythingLLM), which is specific and understandable. However, it does not differentiate from the sibling tool 'anythingllm_upload_file_to_folder', so it lacks full sibling 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 guidance on when to use this tool versus alternatives like 'anythingllm_upload_link', 'anythingllm_upload_raw_text', or 'anythingllm_upload_file_to_folder'. The description does not mention any use cases, prerequisites, or exclusions, leaving the agent without decision support.

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

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

Annotations are all false, providing no meaningful behavioral safety hints. The description adds only the folder prerequisite but fails to disclose important behavior such as whether an existing file with the same name is overwritten, what happens if the folder doesn't exist, or any error conditions. For a mutation tool, this is a significant transparency gap.

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 concise, front-loaded with the primary action, and structured as a clean docstring with an Args section. Every sentence adds value, and there is no filler or redundant 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?

The tool is simple (2 required params) and an output schema exists, so return values need not be explained. The description covers the core action and parameters, but it lacks behavioral edge-case details (overwrite, error handling) and does not relate it to workspaces or other context. It is adequate but not fully complete.

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

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

Schema coverage is 0% (no parameter descriptions), but the description explicitly documents both parameters: file_path as an absolute path and folder_name as a target folder that must already exist. This fully compensates for the schema's lack of detail and adds the 'must already exist' constraint.

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), the source (local filesystem), and the destination (a specific document folder in AnythingLLM). This distinguishes it from sibling tools like anythingllm_upload_file, which likely uploads to a workspace root, and anythingllm_upload_link/raw_text.

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 a prerequisite (folder_name must already exist) but does not explicitly state when to use this tool versus alternatives like anythingllm_upload_file or anythingllm_upload_raw_text. Usage is implied by the name and description, but there are no explicit exclusions or alternative comparisons.

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 this as a write operation (readOnlyHint=false), non-idempotent, and with external side effects (openWorldHint=true). The description adds that it 'scrapes a web page,' which gives a bit more specific mechanism beyond the annotations, but does not disclose any additional behavioral traits such as workspace targeting, failure behavior, or rate limits.

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

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

The description is minimal and front-loaded with the core action. The Args section is neatly separated and adds necessary parameter detail without redundancy. 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?

The description does not specify where the uploaded document is placed (e.g., which workspace or folder), which is a significant ambiguity given sibling tools like upload_file_to_folder. While an output schema exists and annotations cover safety, the missing destination context could confuse an agent about expected effects.

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 provides a single 'link' parameter with no description (0% coverage). The description's 'Args' section compensates fully by defining the parameter as 'URL to scrape' and specifying the required protocol prefix. This is exactly what the agent needs to properly invoke the tool.

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: 'Scrape a web page and upload it as a document to AnythingLLM.' This is a specific verb+resource combination that immediately differentiates it from sibling tools like upload_file or upload_raw_text by specifying the source (web page).

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 a clear use case: when you have a URL to scrape and upload. It also provides a necessary constraint for the link parameter ('must start with http:// or https://'). However, it does not explicitly compare to alternatives like upload_file or upload_raw_text, so it falls 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 provide no safety hints (all hints false), and the description only restates the action without disclosing potential side effects, authentication requirements, or behavior on duplicate titles. For a write operation with no annotation support, the description offers minimal over the name itself.

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 brief and front-loaded, with no extraneous wording. The Args section duplicates schema names but is justified by adding semantic value. It is concise and well-structured.

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

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

The tool is simple and has an output schema, but the description lacks behavioral context such as how duplicates are handled, size limits, or authentication needs. Given the absence of annotation support, more detail would improve completeness.

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

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

The schema has zero description coverage, but the description compensates by defining both parameters: 'text_content' as 'Raw text content to upload' and 'title' as 'Document title'. This adds meaningful context beyond the bare schema types.

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 raw text content as a document to AnythingLLM') with a specific verb and resource. It distinguishes itself from sibling tools like upload_link, upload_file, and upload_file_to_folder by specifying 'raw text' input.

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 through its name and phrasing but offers no explicit guidance on when to choose this over alternatives like upload_link or upload_file. No prerequisites, exclusions, or alternative tool references are provided.

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