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

With no annotations, the description provides key behavioral context: files are linked/copied rather than moved, and there is a hard limit of 50 ids per call. It does not cover error cases or side effects, but the core behavior is disclosed.

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

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

Two sentences, front-loaded with the action, and no filler. Every phrase adds value: the operation, the destination, the file-location behavior, and the limit.

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 2-parameter tool with no output schema and no annotations, the description covers the action, the key non-mutating behavior, and the limit. It lacks details on error handling, but is largely 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?

Schema coverage is 100% with both parameters described ('Destination board album boardKey' and 'Drive objectKey ids to add'). The description adds the maximum count and the linking behavior, but does not add significant 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 clearly states the action: 'Add existing Drive files into a native JioAICloud board album by boardKey.' It specifies the verb (add), resource (Drive files, board album), and mechanism (boardKey), distinguishing it from siblings like jio_move_to_album.

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 noting 'Files stay in My Files (link/copy into the board),' which contrasts with moving via jio_move_to_album. However, it does not explicitly name alternatives or state when not to use 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It does add a useful transparency note ('no secrets') and implies a read-only check, but it does not explicitly state non-destructiveness, whether it makes network calls, or any edge-case behaviors. This is a moderate addition, not a comprehensive disclosure.

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

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

The description is a single, concise sentence (9 words) with no filler. It is front-loaded with the core purpose and includes a meaningful parenthetical safety note. Every word earns its place.

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

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

Given the simplicity of the tool (no parameters, no output schema, no annotations), the description is reasonably complete. It communicates the essential function and a safety guarantee. It does not specify the exact return format, but for a status-check tool, 'show whether... exists' sufficiently conveys the expected outcome. A slightly richer description might note if it returns a boolean or text, but the current text is adequate for this 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 coverage is 100% (vacuously). According to the guidelines, the baseline for 0 params is 4, and the description does not need to explain parameter details that do not exist. It implicitly states the subject of the check, adding semantic context.

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 with a specific verb ('Show') and a well-defined resource ('whether a local JioAICloud session exists'). It clearly differentiates from sibling tools like jio_login (create session) and jio_logout (destroy session).

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

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

The description implies the tool should be used to check session existence, but it does not explicitly state when to use it versus alternatives. There are no direct references to sibling tools or exclusion scenarios, so the usage context is only implied.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'first page sample per category,' which hints at a sampling behavior, but this is ambiguous: it is unclear whether the counts and bytes represent the full totals or are derived from the sample. The description does not clarify read-only nature, authentication needs, or potential side effects, though the verb 'Summarize' suggests a safe read operation.

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, compact sentence that conveys the core purpose and key output elements (counts, bytes, categories, sample). Every word contributes to the meaning, with no redundant phrases or excessive detail. It is front-loaded with the main verb and object.

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 one parameter and no output schema, the description provides a reasonable overview but leaves a critical gap: the lack of any explanation for 'sampleLimit.' An agent would not know how to configure the tool correctly. Additionally, the output structure is only partially described; while 'counts and bytes' are mentioned, the exact return format is not specified.

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 defines a single parameter 'sampleLimit' with zero description coverage. The tool description makes no mention of this parameter, leaving the AI agent without any guidance on its purpose, default value, or effect on output. Since schema coverage is 0%, the description should have compensated, but it does not.

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 a specific verb 'Summarize' and clearly identifies the resource: backup counts and bytes for five distinct categories (photo/video/document/audio/other). This makes the tool's purpose immediately clear and differentiates it from sibling tools like list_files or storage_usage, which serve different functions.

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 a category-level summary of backup counts and bytes is needed. However, it does not explicitly mention alternatives or specify when not to use it. The context is clear enough for an AI agent to make a reasonable choice, but explicit exclusions or comparisons with sibling tools are absent.

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

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

With no annotations, the description carries the full burden. It discloses that kind=folder creates a My Files folder and kind=board creates a native album, and implies that board creation does not automatically add files by recommending jio_add_to_board. However, it does not mention permissions, reversibility, or expected output, which are important for a creation 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 is two sentences long, front-loaded with 'Create an album', and every phrase adds value. It efficiently distinguishes the two kinds and provides a pointer to the sibling tool without any redundant filler.

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

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

Given the lack of annotations and output schema, the description offers a good level of completeness for a create tool: it explains the primary decision (kind), the recommended usage, and how to extend a board with jio_add_to_board. It falls short of covering return values, error cases, or prerequisites, but the core use cases are well addressed.

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 descriptions cover parentId and description, leaving kind and name without schema descriptions. The description compensates by explaining the meaning of each kind value and its recommended workflow, adding semantic value beyond the raw enum. It also clarifies the purpose of the board type in relation to adding files.

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 'Create an album' with a clear verb and resource, then explicitly distinguishes between kind=folder and kind=board. It even references jio_add_to_board for populating a board, which sets it apart from sibling tools like jio_rename_album or jio_delete_album.

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: kind=folder is recommended for organizing photos/videos, while kind=board creates a native album and points users to jio_add_to_board for adding existing Drive files. This clearly indicates the tool's role and directs users to the alternative for a related operation.

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

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

With no annotations, the description carries the full burden and does so excellently. It discloses dry_run default, the need for confirm=true for real deletion, the board-specific network call (PUT /invites/boards/{id}/unjoin), and that board deletion does not trash Drive files. This provides crucial behavioral context beyond the schema and clearly sets expectations.

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

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

The description is three sentences with zero fluff: it front-loads the main purpose, then packs essential mode differences, safety flags, and side-effect distinctions. Every sentence earns its place and the structure is easy to scan.

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

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

Given no output schema and no annotations, the description provides enough operational detail for an agent to invoke the tool correctly: which kind to choose, the required confirmation for actual deletion, the default dry-run safety, and the non-destructive nature for board deletes. It is complete enough to avoid hazardous side 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?

Schema description coverage is 0%, so the description compensates. It explains kind semantics (folder vs board), the role of dry_run and confirm, and references objectKey/boardKey which clarifies how ids are interpreted. The only gap is that it doesn't explicitly restate that 'ids' is the array of album identifiers, but the overall mapping is inferable from the kind-specific language.

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 ('Delete albums') and clearly distinguishes two deletion modes (folder vs board), which differentiates it from sibling tools like jio_delete_files. It explicitly contrasts behavior for each kind, 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 explains when to use each mode: 'kind=folder moves folder album(s) to Trash' and 'kind=board deletes/leaves native board albums'. It also specifies the safety mechanism (dry_run default, confirm required). However, it never explicitly names alternative tools or states when not to use this tool versus jio_delete_files, so it falls short of full 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?

With no annotations, the description carries the full burden. It discloses key behavioral traits: the default dry_run=true and the requirement for confirm=true to perform a real delete. This adds important safety context beyond the schema. However, it does not explain whether the trash is recoverable, permissions needed, or other consequences of deletion, so it is not fully transparent.

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

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

The description is two short sentences, front-loaded with the core purpose and immediately followed by critical safety flags. Every word earns its place, with no fluff or repetition.

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

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

The tool has 4 parameters, no output schema, and no annotations, so the description must cover essential semantics. It addresses safety flags but neglects to explain how to use groupIds (the likely selection mechanism) or what 'trash' entails. An agent would likely struggle to specify the right candidates without additional info. Compared to similar mutation tools, completeness is low.

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

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

Schema coverage is only 25% (only 'all' has a description). The tool description adds meaning for dry_run and confirm by explaining their combined behavior, but it does not explain the 'groupIds' parameter or how to select specific candidates. It partially compensates for the low schema coverage but leaves a significant gap for a key 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 ('Trash delete-candidates') and the specific resource context ('from the last jio_find_duplicates run'), distinguishing it from sibling tools like jio_delete_files and jio_delete_album. It is a specific verb+resource statement with no ambiguity.

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

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

The description provides clear usage context by referencing the prerequisite jio_find_duplicates run and the safety conditions for real deletion (dry_run=false, confirm=true). It does not explicitly mention when not to use it or alternatives, but the context is strong enough for an agent to infer appropriate usage.

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

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

With no annotations provided, the description carries full responsibility. It discloses that the operation moves files to trash (not permanent deletion), the dry_run default, and the explicit requirements for a real delete. This is valuable context beyond the schema fields.

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

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

The description is two sentences with no unnecessary words. It front-loads the primary action and immediately conveys the safety defaults, making it highly efficient.

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 3-parameter tool with no output schema, the description covers the core behavior and parameter semantics well. It explains the soft-delete nature and the flags needed for actual deletion, but omits details like response or reversibility, which are less critical here.

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

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

Schema description coverage is 0%, but the description compensates by explaining all three parameters: ids (objectKey ids), dry_run (default true), and confirm (required for real delete). It adds practical meaning to each parameter, though it does not detail id format or edge cases.

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?

Description clearly states the action 'Move files to trash by objectKey ids' with a specific verb and resource. It distinguishes itself from sibling tools like jio_delete_album and jio_delete_duplicates by focusing on files and the objectKey identifier.

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 the safety mechanism (dry_run defaults to true, real delete requires dry_run=false and confirm=true) but gives no explicit guidance on when to use this tool versus alternatives. There are no scenarios or exclusions mentioned, which is a gap given the many sibling delete 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?

No annotations are provided, so the description carries full responsibility. It discloses the basic behavior of saving to a local downloads folder but omits details about side effects, permissions, or whether destPath overrides the destination. The use of 'objectKey' instead of the schema's 'id' creates confusion.

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

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

The description is a single concise sentence with no filler. It is appropriately sized for a simple tool, though it sacrifices necessary detail for brevity.

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

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

For a tool with two parameters and no output schema, the description is under-specified. It does not explain destPath, does not clarify what objectKey maps to, and does not differentiate from jio_get_file. Despite low complexity, it is not complete enough for reliable invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It introduces 'objectKey', which is not a parameter name in the schema (the actual parameter is 'id'), and completely omits the optional 'destPath' parameter. This provides misleading information and fails to explain both parameters.

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

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

The description clearly states the action (Download), the resource (file by objectKey), and the destination (local downloads folder). However, it does not distinguish this tool from the sibling 'jio_get_file', which may also retrieve files, so it lacks sibling differentiation.

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 when to prefer this over jio_get_file or other list 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions session-scoped state ('from this session') and a read-like operation ('Return'), but does not disclose what happens if no report exists, whether this is truly read-only, or if the report persists across tool calls within the session. This is insufficient for a tool with no annotation support.

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

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

The description is a single, focused sentence that delivers the essential information upfront with no filler or repetition. Every word contributes to understanding the tool's purpose.

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 no-parameter tool, the description is serviceable but leaves gaps. It does not describe the content or format of the returned report, and it relies on the agent already knowing what a 'jio_find_duplicates report' is. Given there is no output schema and no annotations, the description should provide a bit more context about the report's structure or behavior when no report 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 tool has zero parameters, so the baseline is 4. The description does not need to explain parameters since there are none, and no parameter information is missing.

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 ('Return') and identifies a specific resource ('the last jio_find_duplicates report from this session'). This clearly distinguishes it from sibling tools like jio_find_duplicates (which generates the report) and jio_delete_duplicates (which acts on it).

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

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

The phrase 'from this session' implies that this tool should be used after running jio_find_duplicates in the current session, but the description does not explicitly state when to use it, when not to use it, or mention any alternatives. Usage context is implied but not explicitly guided.

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?

There are no annotations, so the description must carry the full behavioral disclosure. It mentions the output destination (downloads/) but fails to explain whether files are overwritten, whether the operation is non-destructive, how pagination works, or what the response looks like. This leaves the agent without a clear safety or side-effect profile.

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 conveys the key action, resource scope, and destination without any filler or repetition. It is optimally concise for the information it provides.

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 four parameters, no annotations, and no output schema, the description is too terse to fully equip an agent. It omits critical context such as what an 'inventory' contains, the effect of 'maxPages', default filename behavior, and any implications of the downloads/ destination, making it incomplete for safe and correct invocation.

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

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

With zero description coverage in the schema, the description must compensate. It does explain the semantics of 'format' (JSON/CSV) and 'category' (photos/videos/documents/all), but it says nothing about 'filename' or 'maxPages'. These two parameters remain undocumented, leaving ambiguity for the agent.

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 exports an inventory of photos/videos/documents or all, to JSON/CSV under downloads/. This makes the tool's specific action and scope obvious, distinguishing it from sibling list and download tools.

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

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

The description provides no guidance on when to use this tool versus alternatives like jio_list_files or jio_backup_summary. It only states what the tool does, without any context on prerequisites, exclusions, or preferred scenarios.

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

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

With no annotations provided, the description carries the full burden. It does disclose the grouping logic (checksum else name+size) and that it works across categories, but it omits essential behavioral information such as whether the operation is read-only, what the return format looks like, or any side effects. The mention of 'custom list' is also unsupported by the schema, adding confusion.

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 short and front-loaded, with the main purpose in the first sentence and grouping detail in the second. It is efficient overall, but the phrase 'or a custom list' introduces ambiguity and could have been omitted or clarified, slightly reducing its polish.

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 four parameters, no output schema, and no annotations, this description is insufficient. It lacks return value details, explanations of key parameters, and any edge-case or behavioral context. An agent would likely struggle to invoke this tool correctly without additional information.

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

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

Schema description coverage is 0%, and the description offers minimal parameter clarification. It partially lists categories (photos/videos/documents) but gives no explanation of policy, maxPages, dateWindowMs, or how to provide a 'custom list' that the description claims. The parameter semantics remain largely opaque.

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 finds duplicate files and groups them by checksum or name+size, which is specific and informative. However, it does not explicitly differentiate from sibling tools like jio_duplicate_report or jio_delete_duplicates, so it loses a point.

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 this tool is for finding duplicate files among specified categories, but it provides no explicit when-to-use or when-not-to-use guidance, nor does it mention any alternative tools. The usage context is only implied, not clearly stated.

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

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

With no annotations, the description carries the full burden. It only states the basic function ('Get metadata') without disclosing behavior on missing files, error handling, authentication requirements, or read-only safety. It adds no context beyond the function 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 a single, concise sentence with no filler. Every word adds meaning, and it is appropriately sized for the tool's simplicity.

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 one parameter and full schema coverage, but the lack of annotations and output schema means the description should provide more context. It does not mention return value specifics, error conditions, or when to prefer this over similar tools. However, as a basic read operation, the current level is minimally adequate.

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

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

Schema coverage is 100% with the parameter 'id' described as 'objectKey'. The description repeats this by saying 'by objectKey/id' but adds no additional semantics like format, validity, or source of the id. Baseline 3 is appropriate when the schema fully documents parameters.

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

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

The description clearly states the action (Get), the resource (metadata for a single file), and the identifier (objectKey/id). It distinguishes from sibling tools like jio_download_file (which retrieves content) and jio_list_files (which lists multiple files).

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 that it should be used over jio_download_file for metadata-only needs or any 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?

No annotations are provided, so the description carries the full burden. It states that importing creates a local session, but does not disclose whether it overwrites an existing session, requires prior authentication, makes network calls, or how the passphrase step is handled. The mention of unlocking without a passphrase parameter is unclear and potentially misleading.

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 compact single sentence (13 words) that front-loads the main action. It is concise, though the 'then unlock with passphrase' clause adds a possibly unnecessary ambiguity; still, it earns a high score for brevity.

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

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

Given the auth-related context with siblings like jio_login and jio_unlock_passphrase, the description does not explain the overall workflow, what the tool returns (no output schema exists), or whether the unlock step is separate. This is a significant gap for a tool that restores a session from browser data.

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

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

Schema description coverage is 100%, and the description of the parameter in prose ('browser userData JSON blob') mirrors the schema's 'JSON string of JioAICloud userData from browser localStorage' without adding meaningful new semantics like format, size, or validation requirements. Baseline 3 is appropriate.

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

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

The description uses a specific verb ('Import') and resource ('browser userData JSON blob') to state what the tool does, and it is distinct from sibling tools like jio_login and jio_unlock_passphrase. However, the phrase 'then unlock with passphrase' creates ambiguity about whether this tool performs the unlock or a separate step, slightly weakening 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 context of use is implied: when you have a saved userData JSON from browser localStorage to create a local session. However, it does not explicitly mention alternatives (e.g., jio_login for fresh logins) or when not to use this tool, so it offers only implied 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?

With no annotations, the description carries the full burden of safety and behavioral disclosure. It clarifies the meaning of the two kinds and the default root, but does not mention pagination behavior, return format, or any side effects. Since this is a read-only listing operation, the omission of explicit read-only guidance is notable but not critical.

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

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

The description is two sentences, starts with the core action, and provides essential detail without unnecessary wordiness. Every sentence earns its place, making it highly efficient.

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 listing tool, the description covers the key distinctions between folder and board, but it lacks details about pagination (limit/nextLink) and the expected return structure. Given that no output schema exists, the description should have provided a bit more on what the response contains.

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 only 25% (only parentId has a description). The description compensates by explaining the kind parameter in detail and noting the default root for parentId, but it does not explain limit or nextLink. This is partial compensation for a low-coverage 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 explicitly states 'List albums' and differentiates between kind=folder and kind=board, with a clear explanation of what each kind represents. This provides a specific verb+resource and distinguishes the tool from sibling operations like jio_create_album or jio_delete_album.

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 when to use each kind (folder for organizing media, board for native albums) and notes the default root for parentId. It gives context for usage but does not explicitly mention alternatives or when not to use this tool, such as the need for pagination with nextLink.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only states that it lists backed-up documents. It does not mention pagination (limit, nextLink), authentication requirements, or what constitutes a 'document,' offering minimal value beyond 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 concise (one sentence), but it is under-specified for a tool with three parameters. It fails to include necessary details about pagination or parameter usage, making it an example of brevity over clarity rather than effective conciseness.

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 3 parameters, no output schema, and no annotations, the description is severely incomplete. It provides no information about return values, pagination flow, or how to use the allPages and nextLink parameters together, making it difficult 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?

Schema description coverage is 0% and the description does not mention any of the three parameters (limit, allPages, nextLink). The agent receives no explanation of how these parameters work or when to use them, so the description fails to compensate for the schema's lack of documentation.

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

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

The description clearly states the verb ('List') and resource ('backed-up documents'), which is a specific resource type. It distinguishes somewhat from sibling tools like jio_list_photos and jio_list_videos, but its relationship to jio_list_files is unclear, so it doesn't fully differentiate.

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. There is no mention of use cases, prerequisites, or exclusions, leaving the agent without direction on selecting this tool over jio_list_files or other list 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?

With no annotations, the description carries full responsibility for behavioral disclosure. It only mentions a default root folder, omitting pagination, recursion, authentication, or return format details, leaving significant 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?

A single sentence with no filler; it is optimally concise, though it sacrifices needed detail. The key information is front-loaded and every word earns its place.

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

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

Given 5 parameters, no output schema, and no annotations, the description is too sparse to fully inform usage. Missing pagination semantics (nextLink), sorting, and response structure are significant gaps.

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

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

The schema covers only 1 of 5 parameters with a description (20% coverage). The description adds minimal semantics by hinting at folderKey ('under a folder') and type ('files/folders'), but offers no explanation for sort, limit, or nextLink.

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

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

The description clearly states a specific action ('List') on a resource ('files/folders') with a scope ('under a folder, defaults to root'), distinguishing it from sibling media-specific list tools like list_photos or list_videos.

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 browsing folder contents but provides no explicit guidance on when to prefer this over alternatives like jio_search_files or jio_list_photos, nor any exclusions or prerequisites.

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

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

There are no annotations, so the description must carry the full burden of behavioral disclosure. The word 'List' implies a read-only operation, which gives a basic safety hint, but it does not disclose pagination behavior, input parameter effects, output format, or any side effects.

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

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

The description is extremely short, bordering on under-specification. While front-loaded and free of fluff, it lacks essential details, making it more of a placeholder than a concise explanation.

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

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

Given the absence of annotations, output schema, and parameter descriptions, this minimal description is grossly insufficient. The agent cannot understand pagination, how to use optional parameters, or what the response contains.

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 0% description coverage, and the description does not explain any of the three parameters (limit, allPages, nextLink). There is no added meaning beyond what the raw schema properties show, leaving the agent to guess their purpose.

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 backed-up photos' clearly identifies the action (List) and the resource (backed-up photos), distinguishing it from sibling tools that list videos, documents, or albums. This is a specific and unambiguous purpose statement, comparable to the high-scoring example 'List ALL calls in date range'.

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 like jio_list_files or jio_list_videos. It does not mention exclusions, prerequisites, or scenarios where it is preferred.

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

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

With no annotations provided, the description alone must disclose behavioral traits, but it only states 'List backed-up videos.' It does not mention pagination behavior, output format, sorting, authentication requirements, or any caveats. The description provides no added behavioral context beyond the tool's 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 a single, front-loaded sentence with no fluff or redundant information. It is appropriately concise for a list operation, though the extreme brevity leaves contextual gaps addressed in other dimensions.

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

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

The tool has three pagination-related parameters but the description gives no explanation of how pagination works, what the output looks like, or how the parameters relate. With no annotations or output schema, this one-sentence description is grossly insufficient for an agent to use 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?

Schema description coverage is 0% and the description adds no meaning for the three parameters (limit, allPages, nextLink). The agent has no guidance on how to use pagination or what values are expected, so the description completely fails to compensate for the missing 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 uses a specific verb ('List') and a specific resource ('backed-up videos'), clearly distinguishing it from sibling list tools like list_photos and list_documents. The phrase 'backed-up videos' adds scope beyond the tool name.

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

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

There is no guidance on when to use this tool versus alternatives such as list_files or list_photos. No prerequisites, exclusions, or context about pagination or filtering are mentioned, leaving the agent to infer usage from the name alone.

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

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

No annotations are present, so the description carries the full burden. It discloses the use of environment credentials, session reuse, and the OTP requirement for first-time logins. While it does not detail every side effect (e.g., whether a new session is saved), it provides substantial behavioral context beyond a simple 'login' statement.

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 highly concise, consisting of three short sentences that front-load the core purpose, then add session behavior and first-time login instructions. Every sentence earns its place without 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?

Given the tool's simplicity (0 params, no output schema), the description covers essential aspects: credentials, session reuse, and OTP workflow. It lacks explicit details about return values or failure behavior, but the provided information is sufficient for an agent to select and invoke the tool correctly in most scenarios.

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 in the schema, the description compensates by explaining that credentials come from environment variables (Mobile + Passphrase) and that an OTP can be set via JIOAICLOUD_OTP or through OTP tools. This adds meaning beyond the empty input schema, effectively documenting the implicit inputs.

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: 'Log in to JioAICloud using env credentials (Mobile + Passphrase).' It uses a specific verb ('Log in') and resource ('JioAICloud'), and the mention of saved sessions and OTP flow distinguishes it from siblings like jio_logout and jio_auth_status.

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 guidance for first-time login: 'send OTP first (jio_send_otp / jio_verify_otp) or set JIOAICLOUD_OTP.' It also mentions using saved sessions when possible, giving context on when the tool may not require OTP. However, it does not explicitly say when to use alternatives like jio_auth_status to check existing login state.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states that the tool clears the 'local saved session,' indicating the primary effect and specifying that it is limited to local data. However, it does not discuss reversibility, side effects, or whether the server session is also invalidated, leaving some ambiguity about the full impact.

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 is front-loaded with the action ('Clear'). It contains no wasted words and is appropriately brief for a tool with no parameters and a straightforward function.

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 logout tool, the description is largely complete, clearly stating the action and the scope (local session). However, it does not clarify whether this is a full logout (including server-side invalidation) or what the return value indicates. Given the simplicity and lack of output schema, the description is minimally sufficient but leaves a couple of minor gaps.

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

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

The input schema has zero parameters, so schema description coverage is 100% by default. Since there are no parameters to explain, the baseline for parameter semantics is 4. The description does not need to add parameter details, and it doesn't, which is appropriate.

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

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

The description 'Clear the local saved session.' uses a specific verb ('clear') and identifies the resource ('local saved session'), which clearly indicates a logout action. This distinguishes it from sibling tools like jio_login and jio_auth_status, as it uniquely deals with terminating the session.

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 explicitly state when to use this tool versus alternatives, nor does it mention prerequisites or exclusions. However, the name 'logout' and the action 'clear session' imply that it should be used when ending a user's session. This is a case of implied usage, aligning with a score of 3.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It clarifies that the destination must be a folder album, and that items[] metadata improves results, but it does not disclose whether the move is permanent, required permissions, or error behavior. This is helpful but not fully transparent.

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

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

Two sentences with no redundancy: the first states the core action and destination, and the second provides optional parameter guidance and the alternative for board albums. 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?

The description is adequate for a move operation with no annotations or output schema. It names the resources, the optional enhancement (items[]), and the sibling alternative, which is sufficient for an agent to select and invoke the tool correctly. It lacks some depth on outcomes but overall 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?

Schema coverage is only 33% (albumId). The description compensates by explaining items[] as 'optional' and listing relevant fields (name/objectType/sourceName), and reinforces albumId as a folder objectKey. The 'ids' parameter is left to inference, but its meaning is clear from the name and the verb 'move'.

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

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

The description uses specific action verb 'Move files or folders' and identifies the target as 'folder album by destination albumId (folder objectKey)', clearly distinguishing it from sibling jio_add_to_board which is for native board albums. This is a precise, unambiguous 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?

Explicitly instructs when to use this tool versus jio_add_to_board ('For native board albums, use jio_add_to_board instead'), and provides guidance on optional items[] with name/objectType/sourceName for best results. This gives clear when-to-use and when-not-to-use 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?

With no annotations provided, the description must disclose behavioral traits, but it does not. Renaming is a mutating operation, yet the description omits side effects, permissions, reversibility, or return behavior. The parentId constraint is a small behavioral nuance but insufficient for full 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 two short sentences: the first states the core action and identifier, the second adds a parameter nuance. Every word earns its place, and the key information is front-loaded.

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

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

For a tool with 3 parameters, no output schema, and no annotations, the description is too skeletal. It fails to mention return type, required permissions, or the effect of renaming on related data. The list of sibling tools adds context but the description itself does not provide enough for confident invocation.

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

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

Schema coverage is low (33%: only 'id' has a description). The description adds meaning to 'parentId' by clarifying it is the current parent folder key, which helps. However, 'name' is not explicitly described, though its purpose is implied by the 'Rename' action. This partial compensation merits a middle score.

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 ('Rename') and the resource ('folder album') with an explicit identifier ('by objectKey/id'). This distinguishes it from sibling tools like jio_move_to_album or jio_create_album, 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 provides no guidance on when to use this tool versus alternatives. The only additional sentence ('parentId should be the current parent folder key when known') is a parameter hint, not usage context. No conditions, prerequisites, or exclusions are mentioned.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does not state whether the search is read-only, whether it searches filenames or content, how results are ordered, or any pagination or performance characteristics. The description is purely functional with no behavioral context.

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

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

The description is one short sentence, front-loaded with the verb, and contains no waste. It is appropriately concise, though its brevity contributes to under-specification in other dimensions.

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 two parameters, no annotations, and no output schema, the description is too minimal to fully prepare an agent for correct invocation. It does not explain return format, search scope, or how to handle limit, and it does not differentiate from list_files beyond the obvious.

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 covers 0% of parameters with descriptions. The description only reinforces that 'query' is a keyword, but leaves 'limit' completely unexplained. It adds minimal value beyond the parameter names themselves.

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 'Search files by keyword' clearly states a specific action (search) and resource (files), and the 'by keyword' qualifier indicates the search mechanism. It distinguishes itself from sibling tools like list_files and get_file, though it does not explicitly explain the differentiation.

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 such as list_files or download_file. There is no mention of scenarios, prerequisites, or exclusions, leaving the agent to infer usage from the tool name alone.

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

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

With no annotations provided, the description takes on full behavioral disclosure. It reveals the side effect (sending an SMS) and precondition (first login, no local session), which goes beyond a simple action phrase. It does not cover edge cases like rate limits or OTP expiration, but the core behavior is transparent.

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, efficiently structured sentence that front-loads the verb and resource, then adds the usage condition in parentheses. No words are wasted.

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

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

For a simple 0-parameter tool with no output schema, the description provides sufficient context: what it does, when it is needed, and its place in the login flow. It could explicitly mention the next step (e.g., jio_verify_otp), but this is implied by the login sequence.

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 there is nothing to explain beyond the schema. The description mentions 'JIOAICLOUD_MOBILE' as a fixed destination, not a parameter, which adds clarity without needing parameter documentation.

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

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

The description clearly states the action ('Send login OTP SMS') and the specific destination ('JIOAICLOUD_MOBILE'), making the tool's purpose unambiguous. It also differentiates from sibling tools like jio_verify_otp and jio_login by explaining its role in the login flow.

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: 'needed only for first login when no local session exists.' This implies when not to use it (if a local session already exists), though it does not explicitly name alternative 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?

With no annotations, the description carries the full burden. 'Get' indicates a read operation and 'logged-in account' clarifies scope, but the description does not disclose the response format, units (e.g., bytes, percent), or whether authentication is required beyond the logged-in account implication.

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 wasted words. It states the purpose 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?

For a zero-parameter read-only tool, the description is mostly complete. It identifies the resource and scope, but since there is no output schema, it could specify what the response contains (e.g., quota limit, current usage, units).

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 adds no parameter-specific meaning, but none is needed.

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

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

The description uses a specific verb ('Get') and resource ('storage quota / usage'), clearly distinguishing it from sibling tools that handle authentication, albums, files, and deletion. The scope is explicit: 'for the logged-in account'.

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

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

The description clearly implies this tool is for checking the logged-in account's storage quota and usage. It does not explicitly exclude alternatives, but none of the sibling tools perform this function, so the context is sufficient.

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

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

No annotations are provided, so the description must carry the burden of behavioral disclosure. It only states that the passphrase comes from JIOAICLOUD_PASSPHRASE, but does not explain side effects, server interaction, or whether it alters session state.

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 redundant wording. It immediately communicates the purpose and input source.

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 lack of annotations, output schema, and usage context, the description is too sparse. It does not explain when this unlock should be called in the authentication workflow or what effect it has, leaving an agent to guess the proper sequencing and consequences.

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 schema provides complete coverage. The description adds relevant context by naming the external environment variable JIOAICLOUD_PASSPHRASE, which is the only input to the operation.

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 ('Unlock') and a clear resource ('account passphrase (2FA)'), and mentions the input source (JIOAICLOUD_PASSPHRASE). This clearly distinguishes it from sibling tools like jio_login, jio_send_otp, and jio_verify_otp.

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

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

No guidance is given on when to use this tool versus alternatives. It does not mention prerequisites (e.g., being logged in or having an OTP verified) or situations where this should be preferred over other auth-related 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?

With no annotations provided, the description carries the full burden. It discloses key behavioral traits: it establishes a session, uses a passphrase from an environment variable (so the agent knows not to pass it as a parameter), and implies a multi-step process. It does not cover failure modes, but it provides meaningful context beyond the schema.

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

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

The description is a single sentence that is concise and front-loaded. Every word adds value, specifying the action, the session establishment, and the environment variable dependency 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 tool's simplicity (one param, no output schema, no annotations), the description is mostly complete. It outlines the tool's role in the authentication flow, though it could improve by explicitly mentioning the prerequisite that an OTP must have been sent beforehand. Overall, it is adequate for an agent to invoke it correctly.

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

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

Schema description coverage is 100% with the 'otp' parameter already described as 'OTP received on mobile.' The tool description adds no new parameter-specific details beyond confirming the OTP is verified. Baseline 3 applies because the schema already handles parameter semantics.

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

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

The description clearly states the tool's purpose: 'Verify OTP and establish a session, then unlock with passphrase from env.' It uses specific verbs and resources, distinguishing it from siblings like send_otp, login, and unlock_passphrase by describing the full sequence it performs.

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

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

The description implies the tool is used after receiving an OTP and that it handles both session establishment and passphrase unlocking, but it does not explicitly state when to use this tool versus alternatives like 'login' or 'unlock_passphrase'. There is no explicit when-not or alternative naming.

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