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. 'Attach' implies a state-changing operation, but the description does not explain side effects, whether the token replaces or complements existing ones, authorization requirements, failure modes, or persistence. This is a meaningful gap for a mutation 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 a single focused sentence with no filler. The key action and object are front-loaded. It is appropriately concise, though it achieves this by omitting potentially useful 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 state-changing auth operation with no annotations and no output schema, this description is under-specified. An agent cannot confidently determine the role of optional parameters, the effect on the session, or the expected return value. Important context is left to inference.

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 loosely identifies library_token and session_token, but says nothing about the optional repo_id and library_name parameters, which are non-obvious without further explanation. The description adds minimal meaning beyond the schema titles.

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

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

The description states a specific action ('attach') and a clear resource ('another library token' to 'a session'). It is understandable on its own and distinguishable from siblings like auth_remove_library or auth_revoke, though auth_register_library has some conceptual overlap.

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

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

The description gives no explicit guidance about when to use this tool versus alternatives such as auth_register_library, auth_login, or auth_reauth. It implies an existing session but does not state prerequisites, exclusions, or the intended scenario.

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 behavior disclosure. It adds meaningful context beyond the schema: 'Password is used once, never stored' and 'full-scope session token.' It does not explain token expiry or whether existing sessions are invalidated, but the provided security-related detail is valuable.

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 tight sentences with no filler. The core action is front-loaded, and the second sentence adds a critical security detail. 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?

This is a simple auth tool with no output schema and no annotations, so the description should cover what the agent needs to call it correctly. It explains the purpose and password handling, but leaves out what the response looks like and what the otp parameter means. Those are important gaps for an agent deciding whether to pass OTP or expecting a token in the result.

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 explicitly names user_id and password)Skip, adding semantic meaning beyond the raw schema. It also notes the password's single-use behavior. However, the optional otp parameter is not mentioned at all, and schema description coverage is 0%, so the description does not fully compensate.

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

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

The description states a specific action: 'Validate user_id+password against Seafile and issue a full-scope session token.' This clearly identifies the tool as the initial login operation and distinguishes it from siblings like auth_reauth, auth_rotate, and auth_revoke.

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 is for first-time authentication by saying it validates credentials and issues a session token McDonald. However, it does not explicitly state when to prefer this over auth_reauth or auth_rotate, nor does it mention 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?

No annotations are provided, so the description must carry the behavioral disclosure burden. It only states the intent (refresh after password change) and does not disclose side effects like invalidating the old session, requiring OTP, or what the refreshed session looks like.

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

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

The description is a single front-loaded sentence with no filler words, which makes it easy to parse. It is concise, although the brevity leaves no room for parameter or behavior details.

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

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

For a 3-parameter auth operation with no annotations and no output schema, one sentence is too thin. An agent is left uncertain about OTP behavior, success/failure responses, token requirements, and how this relates to the other auth tools.

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

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

With 0% schema description coverage, the description was expected to compensate, but it only implies that password is the new password and session_token is the existing session. The optional otp parameter is not mentioned at all, so most parameter semantics remain unexplained.

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

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

The description names a specific operation (refresh a session) and pins it to a concrete scenario (after a password change), which is a clear verb+resource+condition. It does not explicitly contrast itself with auth_login or auth_rotate, so it stops short of full 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?

"After a password change" is an explicit usage context, telling the agent when this tool is appropriate. It gives no exclusions or alternative tool names, so it is clear on context but lacks when-not 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does disclose that the tool validates a token, may create or attach a session, and returns a session token. However, it does not describe failure modes, required permissions, persistence effects, or what 'attach the library to an existing one' changes about the session or library.

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, stating the main action first and then the return value. Every sentence earns its place, and there is no redundant or vague filler.

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

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

With no annotations, no output schema, and 0% parameter coverage, the description needs to compensate by explaining the parameters, side effects, and error behavior. It only covers the high-level session flow)Skip leaving major gaps for an agent trying 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 only adds meaning for library_token and, indirectly, session_token. The parameters repo_id, user_id, and library_name are left completely unexplained, leaving an agent without enough information to populate them correctly.

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

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

The description clearly identifies the resource (library API token) and the action (validate, bootstrap a scoped session, or attach to an existing session), and it specifies the returned value. It is specific enough to convey the tool's core purpose, though it does not explicitly differentiate it from sibling auth tools like auth_login or auth_add_library.

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 usage context: when a library API token needs to be validated and a session needs to be created or extended. However, it gives no explicit when-to-use or when-not-to-use guidance, and no alternatives are mentioned even though several sibling auth tools could be confused with this one.

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 bears full responsibility for disclosing side effects. It states that a token is detached but does not explain whether this invalidates the token, affects other sessions, or requires specific permissions. The one-liner is too sparse to make the behavior 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, front-loaded sentence with no filler. It is appropriately concise for a simple operation, though it could be slightly more informative without losing efficiency.

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

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

For a two-parameter mutation tool with no annotations, no output schema, and no parameter descriptions, this description is far from complete. It omits when to use it, what the parameters mean, and what happens after detachment. An agent cannot confidently invoke this tool based on the provided 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%, so the description must explain the parameters, but it mentions neither session_token nor library_name. The property names are somewhat self-explanatory, yet no meaning is added about formats, constraints, or how they relate to the detach operation. This is a clear gap.

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

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

The description uses a specific verb ('detach') and resource ('library token from a session'), making the operation clear. It is immediately distinguishable from sibling auth_add_library and auth_revoke, which represent the inverse or different auth operations. Even without reading the schema, an agent knows what action this 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?

No guidance is given on when to use this tool versus alternatives. The description does not mention that auth_add_library is the inverse operation or explain scenarios like removing a library from a session after reauthentication. The agent must 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?

With no annotations, the description carries the full burden of behavioral disclosure. It indicates a destructive delete operation, but omits consequences such as irreversibility, whether the current session is invalidated, or whether special authorization is required.

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 wasted words and the core action is front-loaded. It is concise to a fault, but conciseness itself is not the weakness.

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 destructive auth operation with no annotations, no output schema, and an undocumented parameter, 'Delete a session.' is under-specified. It lacks effect details, prerequisites, and expected behavior after 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?

The schema has one parameter with 0% description coverage, and the description does not mention session_token at all. It does not clarify which session is deleted, where the token comes from, or any formatting expectations, leaving the agent to rely on the parameter name alone.

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: 'Delete a session.' It clearly differs from siblings like auth_login, auth_rotate, and auth_status. However, it does not explicitly distinguish itself from alternatives or define what a 'session' refers to, which keeps it from a 5.

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

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

No guidance is given on when to use this tool, whether deleting a session logs out the current user, or which sibling tool should be used instead. Usage is left entirely to inference.

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

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

With no annotations, the description carries the full behavioral burden. It discloses the core action and one invariant ('keeping its credentials'), but does not state whether the old token is immediately invalidated, what the response contains, or any security implications.

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

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

The description is a single, front-loaded sentence with no filler. Every phrase contributes to understanding the tool's core purpose and a key behavioral constraint.

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 an auth mutation with no annotations and no output schema, the description is thin. It does not explain what the tool returns, whether the old token becomes invalid, or whether the replacement token is returned in the response.

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 does clarify that the single session_token parameter refers to the token being replaced. However, it adds no detail about token format, how to obtain it, or what the replacement entails beyond the obvious.

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: 'Replace a session token.' The phrase 'keeping its credentials' adds meaningful scope and helps separate this from auth_revoke or auth_login, though it does not explicitly name sibling tools.

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

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

The description gives no guidance on when to use this tool versus alternatives like auth_login, auth_reauth, or auth_revoke. The use case is only implied by the word 'replace' and the credential-preserving clause.

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?

Since no annotations are provided, the description carries the full burden of behavioral disclosure, but it only says 'nothing secret.' It does not explicitly state that the operation is read-only, whether it requires an active session, or what happens with invalid or expired tokens. The 'nothing secret' note is useful but far from enough for a tool with zero 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 short sentence with no filler, and the main action is front-loaded in the first word. The parenthetical '(nothing secret)' adds relevant behavioral information without bloating the text. It could arguably do more, but as conciseness goes it is 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?

Given that the tool has only one parameter and no output schema, the description gives a reasonable gist: the result will describe a session's scope and libraries. However, it does not clarify what 'scope' means, whether the libraries are access permissions or just names, or what the return structure looks like. For a simple status tool this may be enough, but it leaves room for agent uncertainty.

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 only one required parameter, session_token. The description calls it 'a session's scope' which loosely implies the token identifies the session, but it does not explain where the token comes from, its expected format, or how it should be obtained. For a single self-named parameter this is sufficient only for the most obvious inference.

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 'show' and the resource ('a session's scope and libraries'), making the tool's purpose immediately understandable. It also distinguishes this from sibling auth actions like auth_login or auth_rotate and from list_libraries by focusing on session status rather than a stand-alone library listing. However, it does not explicitly differentiate itself from get_auth_help, leaving some ambiguity about overlap.

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 when you need to inspect a session's scope and associated libraries, but it provides no explicit when-to-use or when-not-to-use guidance. It does not mention alternatives such as list_libraries or get_auth_help, nor does it state prerequisites like having a valid session_token. The usage guidance is adequate but only implicit.

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 must disclose behavioral traits, but it only says 'Copy a file or folder' and 'account token only'. It does not mention whether directories are copied recursively, what happens on destination conflicts, whether the source is preserved, or what authentication is required beyond the terse token hint.

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

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

The description is a single, front-loaded sentence with no filler words. However, for an 8-parameter operation with cross-repo and multi-token implications, this level of brevity is under-specification rather than appropriately concise structure.

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

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

Given 8 parameters, no annotations, no output schema, and no parameter descriptions, the description is far too incomplete. An agent cannot correctly determine how to specify destination repositories, whether tokens are mutually exclusive, or what result to expect, so the tool is underspecified to the point of being unsafe to invoke.

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 minimal meaning over the schema: 'file or folder' loosely suggests is_dir, and 'Copy' implies path and dst_dir roles, while 'account token only' points to account_token. However, the other six parameters (repo_id, dst_repo_id, library_name, session_token, etc.) are left entirely unexplained, and schema 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 clearly states the operation: 'Copy a file or folder'. This provides a specific verb and resource that distinguishes it from related tools like rename_item and move_item, though it does not explicitly name those siblings or describe its exact scope boundaries.

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 copy_item versus alternatives such as move_item or upload_file. The parenthetical 'account token only' hints at an auth requirement but does not explain when copying is appropriate or what conditions would make a different tool preferable.

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 but only states a create side effect. It does not mention path validation, parent directory behavior, idempotency, authorization requirements, or what happens if the directory already 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 a single short sentence with no filler, making it easy to parse and front-loading the core action. It is extremely concise, though arguably too terse given the number of parameters.

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 mutation tool with six parameters, no annotations, and no output schema, a one-sentence description is inadequate. It omits essential context about target location, authentication requirements, return values, and error behavior.

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 needs to compensate by explaining the six parameters. It only indirectly covers 'path' via 'folder' and gives no meaning or usage context for repo_id, library_name, account_token, session_token, or repo_token.

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 ('Create') and resource ('folder'), clearly identifying the core operation. It does not explicitly differentiate it from sibling tools like create_library, but the name and action are unambiguous enough for basic 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 such as create_library or upload_file, and no mention of prerequisites like repo_id or library_name. The description simply states the action, leaving the agent to infer any use 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It only hints at password encryption but says nothing about side effects, authentication requirements (even though account_token and session_token exist in the schema), or what happens if the library already exists. This is severely insufficient.

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, which could be seen as concise, but it is under-specified rather than efficiently structured. It lacks any explanatory content that would justify its brevity. The single sentence does not earn its place because it fails to convey essential information.

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

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

For a creation tool with 4 parameters, no annotations, and no output schema, this description is woefully incomplete. It does not explain what a library is, the purpose of the password, token requirements, or expected behavior. An agent cannot reliably invoke this tool based on this description alone.

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 explain the parameters. It does not mention name, password, account_token, or session_token at all. The parenthetical about password being encrypted is too vague to convey its role or constraints. The agent is left with only parameter titles, which are insufficient.

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

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

The description states a clear verb+resource ('Create a library'), so the primary action is unambiguous. However, the parenthetical '(password -> encrypted)' is cryptic and does not clarify what a library is or how this tool differs from siblings like auth_add_library or auth_register_library, so it fails to distinguish itself.

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

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

There is no guidance on when to use this tool versus alternatives. The description never mentions prerequisites, context, or why one would choose create_library over auth_add_library or other sibling tools. An agent has no basis for deciding between them.

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 must carry the full behavioral burden. It only discloses the non-encrypted library restriction; it does not mention authentication needs, link lifetime, side effects, or expected outcomes.

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

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

One compact, front-loaded sentence with no filler. It is concise, though the brevity comes at the cost of missing operational guidance.

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 an 8-parameter mutation tool with no annotations, no output schema, and no parameter descriptions, this one-sentence description is insufficient. It leaves the agent to guess path format, optional sharing settings, token requirements, and response/error behavior.

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% for 8 parameters, and the description adds no parameter meaning beyond the implied file/folder path. password, expire_days, permissions, repo_id, library_name, and both token parameters are entirely unexplained.

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

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

States a specific verb ('Create'), a specific resource ('public share link'), and a scoping restriction ('non-encrypted libraries only'). An agent can immediately distinguish it from list_share_links or get_download_link.

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?

Provides clear context: use it for files/folders and only for non-encrypted libraries. However, it does not explicitly name sibling alternatives like get_download_link or list_share_links or give conditions for preferring them.

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 burden. It clearly indicates the tool is informational/read-only ('Explain how to obtain...'), which is a useful behavioral signal. However, it does not disclose what the output looks like, whether it performs any side effects, or whether it requires prior authentication.

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 front-loads the action ('Explain') and the subject ('how to obtain Seafile account and library API tokens'). No wasted words.

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

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

For a zero-parameter help tool, the description is largely complete: it states the purpose and implies no inputs. The output schema exists, so return values are presumably documented there. It could be slightly stronger by explicitly noting it is a read-only help action, but the current wording 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 there is no parameter semantics burden. The description correctly implies no inputs are needed, and the schema confirms this. A baseline of 4 is appropriate for a zero-parameter 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 states a clear verb ('Explain') and resource ('how to obtain Seafile account and library API tokens'), which distinguishes it from the sibling auth tools that perform actions like login, rotate, or revoke. It is not a tautology and conveys a help/guidance 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 implies this is a help tool for obtaining tokens, and the sibling names (auth_login, auth_reauth, etc.) suggest it is the explanatory counterpart. However, it does not explicitly state when to use this tool versus auth_login or auth_status, nor does it mention that it requires no parameters.

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. It states that a download URL is returned, but says nothing about required tokens, URL expiry, permissions, or whether any side effects occur.

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 with no filler or redundant information. It is concise, though the brevity comes at the cost of useful 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?

For a tool with six parameters, five of them auth/repository-related, no annotations, and no output schema, this description is far from complete. An agent cannot infer which tokens are needed, how the repository context is resolved, or what kind of URL is produced.

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 defines none of the six parameters. The required 'path' and the optional repo/token parameters are completely unexplained, leaving the agent unable to determine how to populate them correctly.

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

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

The description names a concrete action ('get') and resource ('download URL for a file'), so an agent can infer the tool's core function. However, it does not distinguish this from related siblings such as read_file, get_file_detail, or create_share_link, so it stops short of a 5.

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

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

No guidance is given about when to use this tool rather than alternative file-access or sharing tools. The single sentence leaves tool selection entirely to inference.

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

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

With no annotations, the description must fully disclose behavior. It only says 'Get file metadata' and '(account token only)', which is ambiguous. It does not mention whether authentication is required, if it is read-only, what happens on missing paths, or the return format. This is a significant gap for a metadata retrieval 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 extremely concise (one sentence) with no fluff, which is positive. However, it is under-specified to the point of being unhelpful; the brevity sacrifices critical information. It is not structured, but for the content it has, it is clean.

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 six parameters (one required), no output schema, and no annotations, this description is drastically incomplete. It does not explain what metadata is returned, how parameters interrelate, or when to use this tool. An agent cannot correctly invoke this tool based on this description alone.

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% and the description provides no parameter explanations. The required 'path' parameter is not mentioned, and the optional parameters (repo_id, repo_token, library_name, account_token, session_token) are ignored. The description fails to compensate for the lack of schema descriptions, leaving agents without any idea what each parameter does.

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

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

The description states a clear verb and resource: 'Get file metadata'. This distinguishes it from siblings like read_file which presumably returns content. However, it does not explicitly differentiate from other file-related tools (e.g., list_directory) or mention the output structure, so it is not a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. There is no mention of prerequisites, typical use cases, or exclusions. The only hint is '(account token only)' but it does not explain when account token is required or when to prefer this over read_file or list_directory.

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 indicates a read operation ('Get details') but does not disclose authentication requirements (despite token parameters), side effects, or behavior when multiple identifiers are supplied or when none are. There is no mention of error conditions or rate limits. The description is too terse to convey behavioral 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 a single concise sentence with no redundant wording. It is front-loaded with the core purpose and the lookup method. While it is short, it is not verbose or padded, earning a high score for structure despite the lack of 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?

The tool has 5 optional parameters, no output schema, and no annotations. The description only explains two parameters and gives no information about return format, authentication, error handling, or relationships between parameters. An agent cannot reliably call this tool correctly without additional context, making it highly 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?

With 0% schema description coverage, the description must explain all parameters. It mentions only repo_id and library_name via 'by repo_id or name', leaving repo_token, account_token, and session_token completely unexplained. It also does not clarify whether the 'or' implies mutual exclusivity or priority, nor what happens if both are provided. This is insufficient for an agent to correctly fill 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 states a clear verb and resource ('Get details of one library') and specifies the lookup method ('by repo_id or name'). It distinguishes from list_libraries (which lists multiple libraries) and hints at a singular retrieval. However, it does not explicitly differentiate from resolve_library, which could also resolve a library 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 provides no guidance on when to use this tool versus alternatives like list_libraries or resolve_library. It does not state conditions for selection, exclusions, or prerequisites. The only contextual hint is the phrase 'one library' implying singular retrieval, but that is not explicit 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 behavioral disclosure, but it only explains entry_type values. It doesn't disclose authentication needs, whether recursion is supported, output shape, or potential side effects. 'List' implies a read operation, but most behavioral context is absent.

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 with no filler; both sentences contribute information. It front-loads the action and the entry_type filter. However, it is so terse that it leaves out significant context, though the existing text is 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?

Given no annotations, no output schema, and 0% parameter coverage, the description should provide substantially more context. It does not explain token requirements, recursion behavior, or how path and repo_id interact. An agent would have to infer most of the tool's behavior.

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 clarifies entry_type. The other seven parameters — path, repo_id, recursive, repo_token, library_name, account_token, and session_token — receive no semantic explanation beyond their names. This is insufficient for an 8-parameter 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 uses a specific verb ('List') and resource ('directory'), so an agent knows the operation. It also provides entry_type semantics ('f' files, 'd' folders), which helps distinguish it from siblings like create_directory. However, it doesn't describe what scope or path context applies, so it is clear but not maximally differentiated.

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. The description does not mention that search_files is for searching or how list_directory differs from read_file. An agent gets no routing help from the text itself.

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

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

No annotations exist, so the description must disclose safety and behavioral traits. It states a read-only listing action but doesn't explicitly note it performs no mutation or mention authentication requirements beyond the presence of token parameters.

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?

Single sentence with the verb and resource up front, followed by a compact enumeration of lib_type options. No filler or redundant phrases.

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 three undocumented parameters and no output schema or annotations, the description is incomplete. It lacks explanation of account_token/session_token, return structure, and any pagination or error behavior.

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 must explain all parameters. It only documents lib_type values; account_token and session_token are left undefined in both schema and description, leaving the agent to guess their purpose and format.

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 the specific verb 'List' with resource 'libraries' and clarifies scope via 'visible to the account token', distinguishing it from create/rename/get library siblings. The lib_type enumeration further specifies the kind of libraries returned.

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 filtering values for lib_type and the default, which implies when certain sublists are wanted, but it doesn't explicitly contrast with sibling tools like get_library_info or give conditions for 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 must carry the full burden of behavioral disclosure. It only states the action and optional filters, but does not disclose that this is a read-only operation, that it requires authentication tokens (account_token, session_token), or any rate limits or side effects. The description offers no behavioral context beyond the bare action, which is insufficient for a tool that may involve access 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 a single sentence with no fluff. It front-loads the primary action and states the optional filter in a compact way. Every word earns its place, and there is no redundant information. It is appropriately concise for a simple list operation.

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 5 parameters, no output schema, and no annotations, the description is incomplete. It does not explain the authentication tokens, the return format (e.g., list of share link objects), or any constraints. An agent would not know how to successfully invoke this tool without further schema details or external knowledge. The minimal description leaves significant gaps for a tool with 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 schema provides no descriptions for any of the five parameters (coverage 0%), so the description must explain them. It mentions filtering by 'library/path', which loosely maps to library_name and path, but does not mention repo_id, account_token, or session_token. These token parameters are likely essential for authentication, and the description gives no hint of their purpose or format. Thus the description only partially clarifies two of five 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 states a clear verb ('List') and resource ('share links'), and indicates optional filtering by library/path. It is unambiguous about what the tool does. However, it does not explicitly distinguish it from any sibling tool (the only related sibling is create_share_link, which is a different action), so it misses the chance to clarify scope such as 'all share links for the current account'. This is clear but not maximally 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 provides no guidance on when to use this tool versus alternatives. There is no mention of prerequisites (e.g., authentication), context in which listing share links is appropriate, or exclusions. Since there are no directly competing list tools among siblings, the absence is less critical, but the description still fails to give any situational advice, leaving the agent to infer when this tool is needed.

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 absent, so the description carries the full burden of disclosing behavior. It states the operation (move) but does not disclose side effects such as whether the source is deleted, whether existing destination items are overwritten, or whether the operation is reversible. It also does not mention permission requirements beyond the account token constraint. This is a mutating operation, and the description offers minimal behavioral context, leaving significant room for unexpected behavior.

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

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

The description is a single sentence, very concise, and opens with the core operation. There is no fluff or redundant phrasing. However, extreme brevity here results in under-specification, so while it is concise, the structure is fine but the content is insufficient. The score reflects the format, not the adequacy of content.

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

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

Given the complexity (8 parameters, no parameter descriptions, no output schema, and no annotations), the description is drastically incomplete. It does not explain what the move does in detail, how parameters relate, what the return value looks like, or any edge cases. An agent would likely mis-specify arguments or misuse the tool. The description is far from sufficient for correct invocation.

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

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

Schema description coverage is 0%, meaning the schema itself provides no descriptions for any of the 8 parameters. The description mentions only 'account token only' but does not explain what path, dst_dir, is_dir, dst_repo_id, or other parameters mean or how they interact. With no parameter documentation in either the schema or description, an agent has no way to know how to correctly fill the arguments. The description fails to compensate for the total lack of schema-level 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 operation (move) and the resource (file or folder), and adds a specific constraint (account token only). It distinguishes the tool from siblings like rename_item and copy_item by the verb and scope. The resource and action are unambiguous, so an agent understands what the tool does without opening the schema.

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

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

The description gives no guidance on when to use this tool versus alternatives. It mentions 'account token only' but does not explain when to prefer it over copy_item, rename_item, or other file operations. There is no mention of prerequisites, common use cases, or conditions that would make this tool appropriate versus others. An agent has to infer usage from the sibling 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, the description carries the full burden of behavioral disclosure. It does disclose the binary-file fallback behavior, which is useful, but it omits critical details such as the max_chars truncation effect, authentication/token requirements, or any side effects. The description is too sparse for a tool with 7 parameters.

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 and is appropriately concise, but it under-specifies the tool. It front-loads the primary purpose but lacks the detail needed for correct usage. It is not overly verbose, but the brevity works against completeness.

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 7 parameters, no output schema, and no annotations, the description is severely incomplete. It fails to explain the meaning of optional parameters (repo_id, tokens, library_name, max_chars) or any return-value details beyond the binary fallback. An agent cannot call 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%, so the description must compensate by explaining parameters. It mentions none of the parameters (path, max_chars, tokens, etc.), leaving the agent to infer their meaning solely from names. The description adds no semantic value to any 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 reads a text file, with a specific verb and resource. It also adds a note about binary file behavior (metadata + download link). However, it does not differentiate from siblings like get_file_detail or get_download_link, which could overlap in 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?

No guidance on when to use this tool versus alternatives. It does not mention that this tool is for reading file contents as opposed to getting metadata or download links, nor does it state 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?

With no annotations, the description carries the full burden of behavioral disclosure. It does not mention side effects, whether existing names are overwritten, whether authentication tokens are required, or what happens on failure. The only behavioral hint is 'repo token: folders only,' which is terse and ambiguous. This is insufficient for a mutation tool with eight parameters.

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

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

The description is a single, front-loaded sentence with no filler. It communicates the core operation clearly. However, it is almost too sparse for a tool with eight parameters, so it is concise but not optimally structured for an agent's needs.

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 high parameter count, missing annotations, and no output schema, the description is not complete enough. It leaves unclear how tokens relate to file versus folder operations, what path semantics are expected, and how this interacts with sibling operations. The one parenthetical hint is not enough context 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%, and the description does not explain the meaning of path, new_name, is_dir, repo_id, or the various token parameters. It only mentions file/folder and repo token indirectly, which adds almost no value beyond the raw schema. An agent cannot confidently populate parameters from this description alone.

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: 'Rename a file or folder.' This clearly identifies the operation and distinguishes it from sibling tools like move_item or copy_item, since renaming is a distinct action. The parenthetical '(repo token: folders only)' adds a scope constraint but is somewhat cryptic and could confuse agents.

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. The description does not mention that move_item/copy_item should be used for moving or duplicating, nor when to choose directory renaming over file renaming. The parenthetical is a constraint, not a usage recommendation, so an agent is left to infer the appropriate 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, the description carries the full burden of disclosing side effects. It only says 'rename' but doesn't mention whether this is destructive, whether tokens are required, what happens to the old name, or any other behavioral traits.

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, but it's under-specified rather than appropriately concise. It omits almost all necessary information and doesn't earn its single sentence beyond restating the name.

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 mutation tool with five undocumented parameters, no output schema, and no annotations, a one-sentence restatement is completely inadequate. An agent cannot determine how to call 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 coverage is 0% and the description doesn't explain any of the five parameters. It's unclear whether name or library_name holds the new name, and repo_id, account_token, and session_token are entirely unexplained.

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 'Rename a library.' is a direct restatement of the tool name rename_library; it adds no new information about scope, what a library is, or how this differs from rename_item. It qualifies as tautology rather than a clarifying statement.

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

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

No information about when to use this tool versus rename_item, create_library, or other siblings. The description provides no context, prerequisites, 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?

No annotations are provided, so the description must carry the disclosure burden. 'Resolve' implies a read-only operation and 'account token only' hints at an auth constraint, but the description does not clarify whether account_token is required, how session_token behaves, what errors may occur, or whether any side effects 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 a single sentence with no filler, front-loading the action and output. It is concise, though the parenthetical 'account token only' is slightly cryptic and could be clearer.

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 no annotations, no output schema, and 0% parameter coverage, this one-liner is too thin. It leaves auth semantics, token requirements, and details about the returned repo_id unspecified, so an agent lacks enough context to invoke it confidently.

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 gives some meaning to library_name and account_token, but session_token is never mentioned, token formats or requirements are not explained, and repo_id is left undefined.

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

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

The description uses a specific verb and resource ('Resolve a library name to its repo_id'), making the action clear as a lookup/translation. It is distinguishable from siblings like list_libraries and get_library_info by its focus on producing a repo_id, though it does not explicitly contrast with those 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?

There is no guidance about when to use this tool versus alternatives. The parenthetical 'account token only' hints at a constraint but does not explain when to prefer resolve_library over get_library_info, list_libraries, or auth-related sibling tools.

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

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

With no annotations, the description carries the full burden. It discloses a meaningful prerequisite (server-side search enabled) and an auth constraint (account token only). But it does not state whether the operation is read-only, what it returns, or any rate limits or side effects.

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

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

The description is a single sentence, front-loaded with 'Search files,' and contains no filler. The parenthetical is slightly cryptic but compact.

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 6 parameters, no output schema, and no annotations, this description is under-specified. It does not explain parameter roles, return value, or edge cases, leaving an agent to rely on inference.

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 only references account_token, leaving query, repo_id, repo_token, library_name, and session_token unexplained. The purpose of 'query' is inferable from context, but most parameters are not described.

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 and resource ('Search files') and adds a scoping constraint about account token and server search. It is not a tautology, and the action distinguishes it from browsing tools like list_directory, though it doesn't explicitly name alternatives.

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

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

The description gives a prerequisite: 'account token only; needs search on server,' which implies when the tool can be used. However, it does not provide explicit guidance on when to use this over sibling tools like list_directory or read_file.

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 that the operation overwrites and creates a new version, implying some mutation and history behavior, but it does not mention authentication requirements, potential destructive consequences, or response details. This is minimal disclosure for a write 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 extremely short, which is concise, but it sacrifices substance. Important behavioral and parameter information is missing, making this under-specification rather than efficient brevity. There is no front-loading of critical details beyond the basic action.

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 eight parameters, many optional, and no output schema, the description is grossly incomplete. It provides no explanation of parameter semantics, no guidance on when to use it, and no information about authentication or side effects. An agent would struggle to use this correctly without additional external knowledge.

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 mentions none of the eight parameters. It fails to explain critical ones like path, content, is_base64, or the various token parameters. The agent must rely entirely on the bare schema titles, which is inadequate for correct invocation.

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 'Overwrite a file (new version in history)' clearly identifies the verb and resource, and the parenthetical adds a distinguishing detail about versioning. It is specific enough to understand the core action, though it does not explicitly contrast with upload_file or other sibling 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?

No guidance is provided on when to use this tool versus alternatives like upload_file or read_file. The description only states what it does, leaving the agent to infer the appropriate context without any explicit conditions 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It reveals that content can be text or base64, but it says nothing about replacement semantics, authentication requirements, side effects of overwriting, or what happens when replace=false.

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

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

The description is a single front-loaded sentence with no filler or repetition. It is appropriately concise for its core message, though for a nine-parameter tool, additional structured detail would be expected for a top score.

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 nine parameters, no annotations, and no output schema, the description omits critical invocation details: replace behavior, token usage, repo_id meaning, and path format. It defines the high-level action but leaves too much for the agent to infer or guess.

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 only adds meaning to content and is_base64 via 'text or base64.' The remaining seven parameters — replace, repo_id, repo_token, library_name, account_token, session_token, and path — receive no added 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 uses an explicit verb and resource: 'Upload/create a file,' so an agent knows the operation and target. The parenthetical 'text or base64' clarifies the supported content modesahan. It does not explicitly name or distinguish itself from the sibling update_file, so it misses full 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?

No guidance is given about when to use upload_file versus update_file, create_directory, or read_file. There are no usage context, exclusions, or prerequisites, so the agent must infer when this tool is appropriate from the verb alone.

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